GolemBot — Summary

GolemBot is a TypeScript npm package (golembot) that gives any coding agent (Cursor, Claude Code, OpenCode, Codex) a "body" by connecting it to messaging channels (Slack, Telegram, Discord, Feishu, DingTalk, WeCom, WeChat) and exposing a programmable HTTP API for product embedding. It works by wrapping the underlying coding agent CLI as a subprocess — GolemBot handles channel message parsing, routing to the agent engine, streaming responses back, and session persistence, but delegates all intelligence to the agent. The key insight is provider-routing: a single provider config block can redirect any engine through OpenRouter, MiniMax, DeepSeek, or SiliconFlow without code changes, enabling Codex running on DeepSeek or Claude Code through OpenRouter in one command. GolemBot bundles access to 13,000+ community skills from the ClawHub ecosystem with one-command install. Closest seed analog is openspec (cross-tool multi-entry-point design), but GolemBot's value proposition is external-channel bridging rather than spec management — it is an agent-to-IM-gateway, not a coding workflow orchestrator.

GolemBot — Overview

Origin

Published on npm as golembot v0.47.1 by 0xranx. 285 GitHub stars (2026-05-09 last commit). The project emerged from the practical problem of coding agents being stuck in a terminal window — the author's insight was that the agent is already "smart enough"; what it needs is a communication channel.

Philosophy

"Any Agent × Any Provider × Anywhere"

"Cursor, Claude Code, OpenCode, Codex — these Coding Agents can already write code, run scripts, analyze data, and reason through complex tasks. But they're stuck in an IDE or a terminal window. GolemBot gives them a body."

The framework deliberately avoids implementing AI logic:

"GolemBot does not manage context window, dispatch tools, reason, or set session TTL. All 'intelligent' behavior is delegated to the underlying Coding Agent."

From CLAUDE.md (hard architectural constraints):

"Don't add new core concepts — The framework has only two concepts: assistant directory + Skill." "Don't declare Skills in config — The skills/ directory is the single source of truth."

Key Differentiators

1. Channel-first: Primary value is IM channel bridging (7 channels: Slack, Telegram, Discord, Feishu, DingTalk, WeCom, WeChat)
2. Provider routing: Decouple the agent engine from its LLM provider without code changes
3. ClawHub integration: One command to install from 13,000+ community skills
4. Minimal abstractions: Only two concepts — assistant directory (golem.yaml) and Skills

Architecture Philosophy (from CLAUDE.md)

• Never put CLI logic in core library — cli.ts is a thin shell
• StreamEvent interface identical across all engines — switching requires zero code changes
• chat() calls with same sessionKey must be serialized (KeyedMutex); different sessionKeys run in parallel

GolemBot — Architecture

Distribution

• Type: npm-package
• Binary: golembot (via bin: { golembot: './dist/cli.js' })
• Version: 0.47.1
• Language: TypeScript (compiled to dist/)

Install Methods

npm install -g golembot
# Then:
mkdir my-bot && cd my-bot
golembot onboard    # guided setup
# Or manually:
golembot init -e claude-code -n my-bot
golembot run        # REPL
golembot gateway    # IM + HTTP service + Dashboard

Required Runtime

• Node.js >= 18
• One or more coding agent CLIs installed: claude (Claude Code), agent (Cursor), opencode, or codex

Directory Structure (per assistant)

my-bot/
├── golem.yaml          # Engine, name, and infrastructure config (NOT skills)
├── skills/             # Markdown skills — single source of truth
│   ├── general/        # Built-in skill templates
│   ├── im-adapter/     # IM channel-specific skills
│   ├── escalation/     # Escalation handling
│   ├── kb-guide/       # Knowledge base guidance
│   ├── message-push/   # Push notification skills
│   ├── multi-bot/      # Multi-bot coordination
│   └── task-manager/   # Task management skills
└── AGENTS.md           # Auto-generated from workspace

golem.yaml Schema (minimal)

name: cloudsync-support-bot
engine: opencode     # one of: cursor | claude-code | opencode | codex

Provider Routing Config (in golem.yaml)

provider:
  type: openrouter    # or minimix, deepseek, siliconflow
  api_key: ${OPENROUTER_API_KEY}
  model: anthropic/claude-3.5-sonnet

Engine Implementations

All engines implement the AgentEngine interface with a single invoke(prompt, opts): AsyncIterable<StreamEvent> method:

• ClaudeCodeEngine — ~/.local/bin/claude -p <prompt> --output-format stream-json --verbose --dangerously-skip-permissions
• CursorEngine — ~/.local/bin/agent --output-format stream-json --stream-partial-output --force --trust --sandbox disabled
• OpenCodeEngine — opencode run <prompt> --format json
• CodexEngine — codex exec --json --full-auto --skip-git-repo-check [--model X] <prompt>

Channel Architecture

Slack / Telegram / Discord / Feishu / DingTalk / WeCom / WeChat / HTTP API
  Custom Adapters (email, GitHub Issues, ...)
          │
          ▼
  Gateway Service (Channel adapters + HTTP service)
          │
  createAssistant() → GolemBot runtime
          │
  ┌───────┬───────┬───────┐
  ▼       ▼       ▼       ▼
Cursor  Claude  OpenCode  Codex
        Code
  ↕ Provider Routing (OpenRouter, MiniMax, ...)

Target AI Tools

Cursor, Claude Code, OpenCode, Codex — any of the 4 supported engines.

GolemBot — Components

CLI Commands (golembot binary)

Engine Implementations (src/engines/)

Channel Adapters (src/channels/)

Core Modules (src/)

Skill Templates (templates/)

Skills Directory (skills/)

Skills are plain Markdown files in skills/. The skills/ directory is the single source of truth — golem.yaml only configures engine and infrastructure:

Embedding API (5 lines)

import { createAssistant } from 'golembot';
const bot = createAssistant({ dir: './my-agent' });
for await (const event of bot.chat('Analyze last month sales data')) {
  if (event.type === 'text') process.stdout.write(event.content);
}

Session Management

Sessions are keyed by sessionKey. Same key → serialized (KeyedMutex). Different keys → parallel execution. Session IDs are passed to agent engines for --resume / --session / exec resume continuity.

GolemBot — Uniqueness

differs_from_seeds

GolemBot shares no close analog in the 11 seeds. The closest is openspec in that both aim for cross-tool portability (multiple agent engines, multiple entry points), but openspec adds a spec management layer while GolemBot deliberately adds nothing beyond channel bridging. GolemBot is architecturally opposite to frameworks like superpowers or BMAD-METHOD — those inject behavior into the agent; GolemBot just routes the agent's output to new destinations. The fleet/gateway pattern is unique in the corpus: none of the seeds address connecting coding agents to IM channels or providing multi-bot fleet monitoring. The provider-routing feature (same engine, different LLM provider, zero code changes) is also novel — taskmaster-ai has multi-model role assignment, but GolemBot's provider routing is about infrastructure routing rather than task-role mapping.

Distinctive Positioning

1. Minimal abstraction philosophy: Two concepts only (directory + Skills) and an active commitment to not growing that surface. The CLAUDE.md explicitly bans adding Tool, Blueprint, Registry, or Pipeline abstractions.
2. IM channel bridging: First-class multi-channel support (7 IM channels) for connecting coding agents to team communication. No other seed framework addresses this.
3. Provider routing without framework changes: The provider config block decouples engine from provider — you can run Claude Code through OpenRouter without modifying any framework code.
4. ClawHub ecosystem: Access to 13,000+ community skills, making GolemBot the entry point to the largest community skill library referenced in this batch.
5. Embedding API: createAssistant() with 5 lines of code — the only framework in this batch designed for embedding agent capabilities into existing Node.js products.

Observable Failure Modes

• Provider lock-in for Codex: Custom Codex providers must support the Responses API, which many providers don't — routing Codex through /chat/completions providers silently fails
• No coordination between Fleet instances: Fleet is monitoring only — multiple GolemBot instances don't share session state or coordinate on tasks
• Skills are static at invocation: Skills are read from disk at each chat() call; dynamic skill updates require process restart
• Channel auth complexity: 7 different IM platforms each require separate bot setup and token management
• No built-in memory: GolemBot is stateless beyond session ID mapping — agents lose context if the session ID mapping is lost