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
- FA score
- 45/100 · Major gaps
At a glance
- How it runs
- 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
- 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.
- Source review
- 45/100 · Major gaps
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.
- A team already using Claude Code or Codex wants colleagues to @ a bot in Slack or Feishu to refactor code and inspect files.
- 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().
- An organization needs to move Codex or Claude Code onto a different provider (OpenRouter, MiniMax, DeepSeek, SiliconFlow) without touching code.
- An engineering team wants cron-driven dependency audits or test reports delivered automatically into a chat channel.
- A Discord or Telegram community wants an assistant that can read images and run scripts, not just chat.
- 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 golembotCreate 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-botDocker 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 lsEmbed 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-analysiscurl -X POST http://localhost:3000/abortWhat are this agent's strengths and limitations?
- 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.
- 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: unrestrictedwith 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?
Why each dimension lost points
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.
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.
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.
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.
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.
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.
- 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.
FAQ
Does GolemBot call the LLM itself?
What does it cost to run?
How do I cancel a long-running task?
/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?
Can I connect a message source that isn't built in?
_adapter pointing at a local .js/.mjs file or npm package, or ingest through the HTTP API or createAssistant().