GolemBot

Give your coding agent a body: connect Cursor, Claude Code, OpenCode or Codex to chat apps and your own product, with any LLM provider.

Source repo
0xranx/golembot
Stars
★ 322
Last updated
7d ago
License
MIT
Primary language
TypeScript

At a glance

How it runs
CLISelf-hosted serviceLibrary / SDK
Works with
Universal · cross-platformCodex · Claude CodeOpenAI API · Claude API (Partial support)
Cost
Free software; you pay for model usage
Setup effort
Medium · a few setup steps
You'll need
Node.js >=18npm package golembotCursor / Claude Code / OpenCode / Codex engine CLILLM provider API keyShell / CLINetwork accessLocal filesystem
Typical use
A team already using Claude Code or Codex wants colleagues to @ a bot in Slack or Feishu to refactor code and inspect files.
Not a fit if
  • Teams that want a bot with no external coding-agent CLI underneath.
  • Users who expect zero YAML config and a purely browser-based setup.
  • Teams routing Codex through providers that only expose /chat/completions.

What does this agent do, and when should you use it?

GolemBot is a TypeScript gateway that wraps an existing coding agent — Cursor, Claude Code, OpenCode or Codex — instead of implementing its own reasoning loop. A single golem.yaml defines the engine, optional provider routing (baseUrl, apiKey, model) and per-channel credentials; golembot gateway then starts channel adapters for Slack, Telegram, Discord, Feishu, DingTalk, WeCom, WeChat and an HTTP API alongside a built-in Dashboard. Applications embed the same brain through createAssistant() and consume streamed events such as event.type === 'text'. It follows the SKILL.md format and is compatible with 13,000+ ClawHub community skills, ships cron scheduling, image handling and task cancellation via /stop, assistant.cancel() or POST /abort. The StreamEvent interface is identical across all four engines, so swapping engines or providers is a config change rather than a rewrite.

golembot init -e <engine> -n <name> scaffolds golem.yaml and a skills/ directory; golembot run opens a REPL conversation; golembot gateway boots channel adapters and HTTP service, routing inbound IM messages through createAssistant() to the chosen engine CLI and streaming back events. Provider settings are injected into the engine, so Claude Code can run through OpenRouter, Codex on MiniMax, or OpenCode against DeepSeek with one config block. Inbound IM images are saved to disk for the agent to read and analyze; the built-in cron scheduler pushes standups, dependency audits and test reports into chat channels. Long-running work can be cancelled without clearing session history via /stop, assistant.cancel(sessionKey?) or POST /abort. golembot skill search and golembot skill add clawhub:<skill> handle skill discovery and installation, all with --json output.

  1. A team already using Claude Code or Codex wants colleagues to @ a bot in Slack or Feishu to refactor code and inspect files.
  2. A product team wants to embed a working coding agent into their SaaS or support tooling with a few lines of Node.js via createAssistant().
  3. An organization needs to move Codex or Claude Code onto a different provider (OpenRouter, MiniMax, DeepSeek, SiliconFlow) without touching code.
  4. An engineering team wants cron-driven dependency audits or test reports delivered automatically into a chat channel.
  5. A Discord or Telegram community wants an assistant that can read images and run scripts, not just chat.
  6. A developer wants to plug a custom message source, such as email or GitHub Issues, into the same agent brain via a custom adapter.

How do you install or deploy this agent?

Requires Node.js >=18 and at least one engine CLI (Cursor, Claude Code, OpenCode or Codex) already installed with its credentials.

Install globally:

npm install -g golembot

Create a project and initialize:

mkdir my-bot && cd my-bot
golembot onboard      # guided setup (recommended)

Or initialize manually:

golembot init -e claude-code -n my-bot

Docker deployment:

FROM node:22-slim
RUN npm install -g golembot
WORKDIR /assistant
COPY . .
EXPOSE 3000
CMD ["golembot", "gateway"]

How do you use this agent?

Configure engine, provider and channels in golem.yaml; sensitive fields accept ${ENV_VAR} references:

name: my-assistant
engine: claude-code

provider:
  baseUrl: "https://openrouter.ai/api"
  apiKey: "${OPENROUTER_API_KEY}"
  model: "anthropic/claude-sonnet-4"

channels:
  slack:
    botToken: ${SLACK_BOT_TOKEN}
    appToken: ${SLACK_APP_TOKEN}
  telegram:
    botToken: ${TELEGRAM_BOT_TOKEN}
  my-email:
    _adapter: ./adapters/email-adapter.js
    token: ${EMAIL_TOKEN}

gateway:
  port: 3000
  token: ${GOLEM_TOKEN}

Talk locally, start the gateway, or list running bots:

golembot run
golembot gateway
golembot fleet ls

Embed it in your own code:

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);
}

Manage skills and cancel long tasks:

golembot skill search "data analysis"
golembot skill add clawhub:data-analysis
curl -X POST http://localhost:3000/abort

What are this agent's strengths and limitations?

Pros
  • Reuses a battle-tested coding agent as the brain, so there is no LLM API plumbing, RAG stack or prompt engineering to build.
  • Provider freedom across four engines — OpenRouter, Requesty, Opper, MiniMax, DeepSeek, SiliconFlow — switched through one config block.
  • Identical StreamEvent interface across Cursor, Claude Code, OpenCode and Codex means zero code changes when swapping engines.
  • 100% SKILL.md compatible with 13,000+ ClawHub skills, installable in one command, and the agent itself can search and install skills mid-conversation.
  • Wide delivery surface: seven IM channels plus HTTP API, custom Node.js adapters, and a five-line library embedding path.
  • Bundled Dashboard, Fleet aggregator and cron scheduler give visibility and recurring automation out of the box.
Limitations
  • Depends on external engine CLIs and their credentials (CURSOR_API_KEY, ANTHROPIC_API_KEY, CODEX_API_KEY or ChatGPT OAuth); upstream changes can break it.
  • Codex defaults to codex.mode: unrestricted with sandboxing disabled, so teams must switch to safe mode or tune sandbox/approval explicitly.
  • Routing Codex through a custom provider requires OpenAI Responses API support; providers exposing only /chat/completions or Anthropic /messages will fail.
  • Each chat platform needs its own bot token, app ID or secret, so a multi-channel rollout is a nontrivial configuration task.
  • The repository gives no Windows-specific caveats, memory footprint, or version-compatibility matrix for the four engine CLIs.

How does this agent compare with similar options?

The README explicitly contrasts GolemBot with traditional AI frameworks, where you wire up LLM APIs, chains, RAG, vector databases and prompt tuning yourself, and with thin API-wrapper chatbots that lack real code execution. GolemBot instead reuses an existing coding agent as the brain and swaps engines or providers via one config block.

Key facts side by side with the most closely related agents.

Agent Source review Form / cost Stars Updated Language Full support on
GolemBot This agent 45 · Major gaps CLIFree + model costs ★ 322 7d ago TypeScript Codex · Claude Code
Lemon Persistent Coding Agent 58 · Major gaps CLIFree + model costs ★ 136 today Elixir OpenAI API · Claude API
senpi 74 · Some gaps CLIFree + model costs ★ 511 1d ago TypeScript OpenAI API · Claude API
Pi Agent Harness 42 · Major gaps CLIFree + model costs ★ 120k today TypeScript OpenAI API · Claude API

How does FollowAgents rate this agent?

FollowAgents source review · FARS-2.1
Major gaps
45/ 100 5-point scale 2.3 / 5
Trust 10/29
Reliability 6/14
Adaptability 10/18
Convention 9/18
Effectiveness 7/13
Verifiability 3/8
Why each dimension lost points
Trust10 / 29 · 1.7/5

Docs explicitly show permissive defaults: skipPermissions defaults true, Codex defaults to mode: unrestricted (--dangerously-bypass-approvals-and-sandbox), Cursor runs with --force --trust --sandbox disabled, Claude Code with --dangerously-skip-permissions. Granular permissions are Cursor-only and parsed-but-ineffective elsewhere. User confirmation is thin (only skill install mentions confirmation). Data flow transparency covers ${ENV_VAR}/.env but not how messages/files reach third-party LLMs and IM platforms. Dependencies are common npm packages with optional IM SDK peers, but no audit or lock evidence. Rollback is limited to /reset and /stop, no config/state rollback. Source attribution has MIT and repo link but publisher is unverified. Clear deductions.

Reliability6 / 14 · 2.1/5

Docs are internally consistent (engine comparison, config fields, FAQ align), but dependency availability relies on optional peerDependencies without documented degradation; failure messages are limited to timeout error events and doctor checks, lacking error taxonomy and recovery guidance.

Adaptability10 / 18 · 2.8/5

Audience and scenarios are well covered (IM, library embed, HTTP, scheduled tasks) and capability boundaries include engine comparison and Codex Responses API constraint; trigger precision (groupPolicy, mention handling) is high-level only, and environment fit (Node>=18, Docker) has examples but lacks platform-specific detail.

Convention9 / 18 · 2.5/5

Information architecture is good, install notes are thorough, FAQ and examples are ample, MIT license is complete; naming stability (v0.52.0, semantic-release but no CHANGELOG file), scattered known limitations, and unclear maintenance responsibility (unverified publisher, no governance) cause deductions.

Effectiveness7 / 13 · 2.7/5

Output usability is high (REPL, Dashboard, library API, multi-channel), marginal value is clear (reuse existing Coding Agent); cost-benefit lacks quantification (token cost, concurrency limits, provider fees), only timeout/concurrency defaults.

Verifiability3 / 8 · 1.9/5

README claims 1252+ unit tests and e2e scripts, but static files provide no test content or results; CI only shows lint/build/test steps, coverage unverifiable; fact/inference separation is weak, several performance and compatibility claims lack traceable evidence.

Risks and how to mitigate them
  • Defaults are highly permissive (skipPermissions=true, Codex unrestricted, Cursor/Claude Code bypass approvals); tighten and audit before production use.
  • Granular permissions apply only to Cursor; other engines silently ignore them, risking false security assumptions.
  • Messages and files flow to third-party LLMs and IM platforms; data flow and retention are not systematically documented.
  • Publisher identity is unverified; maintenance responsibility and update path are unclear.
  • Test counts and e2e claims cannot be verified from static files; CI only shows steps.
Evidence confidence: Low Reviewed Nov 06, 2026 Reviewed revision aa310a0b28f4
See the full review method →

FAQ

Does GolemBot call the LLM itself?
No. Reasoning and tool use come from the engine you select (Cursor, Claude Code, OpenCode or Codex); GolemBot handles channels, provider routing and session management.
What does it cost to run?
GolemBot itself is MIT-licensed and free, but you pay for the coding agent's subscription or quota plus per-token charges from whichever LLM provider you route through.
How do I cancel a long-running task?
Send /stop in the REPL or an IM channel, call assistant.cancel(sessionKey?) in code, or POST /abort over HTTP; session history is preserved.
How do the engines differ in runtime permissions?
Cursor runs with --force --trust --sandbox disabled, Claude Code with --dangerously-skip-permissions, OpenCode per its permission config, and Codex defaults to unrestricted with optional sandbox, approval, search and addDirs settings.
Can I connect a message source that isn't built in?
Yes. Add a custom adapter under channels with _adapter pointing at a local .js/.mjs file or npm package, or ingest through the HTTP API or createAssistant().
View on GitHub ↗ Install ↓

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related agents