Use Codebolt where you work
CLI
Install globally with npm. Run in your terminal. Use a built-in agent or write your own — full SDK access, any LLM provider.
npm i -g codebolt ~ codebolt
Build software with Codebolt. Run and coordinate hundreds of autonomous agents across laptops, cloud, and fleets. Ship Codebolt-native applications that run directly on the engine runtime.
Install globally with npm. Run in your terminal. Use a built-in agent or write your own — full SDK access, any LLM provider.
npm i -g codebolt Start like Claude Code. Scale like nothing else exists. One engine. Every scale.
Claude Code is an agent. OpenClaw is an assistant. Cursor is an editor. Codebolt is the engine that can become any of them — and scale beyond all of them.
Agent-native software has properties traditional software doesn't. Codebolt is the engine that makes them possible.
Autonomous loops, hooks, schedules, webhooks. The agent stays in motion without you driving it. You don't have to be in the loop for work to happen.
Define what good looks like with eval tasks. The optimizer iterates on prompts, tools, and configs across runs. Your agents get measurably better with use, not worse.
Lives where customers already are — Slack, Telegram, Discord, email, web. The Routing Gateway carries the same agent to every surface, no glue code.
Agents call agents. Multi-agent by default. Stigmergy, deliberation councils, review-merge — coordination is built in, not bolted on.
Build software. Build a custom harness. Run autonomous. Build on top — the same engine covers the full arc, from your first agent to applications that run on top of Codebolt.
Use the Editor, CLI, or terminal as a coding partner — like Claude Code, but with custom agents, any LLM, and full SDK access. Then push beyond software: spin up agents that draft documents, edit videos, run research, generate decks. Anything an agent can do, you can build a workflow for.
Don't settle for someone else's agent loop. Write custom agents in JavaScript with the 63-module SDK — full control over prompts, tools, memory, and routing. Build custom plugins that run inside the engine on three communication channels. Or ship custom UIs on top of the Client SDK. Your agents, your tools, your rules.
Same content as the section above, in a bento grid layout. Compare and pick the one you like.
Write agents in JavaScript with 63+ SDK modules. Full control over the agentic loop — prompts, tools, memory, routing.
Learn more →Run inside the engine on three channels — WebSocket actions, multiplexed events, HTTP REST.
Learn more →Inherit a base agent. Customize in YAML + Markdown. Git-friendly. No code required.
Drag-and-drop agent workflows. LiteGraph editor. Compose agents with no code.
Build dashboards, panels, mobile apps. 72 REST + 33 WebSocket modules.
Learn more →Promote your agents to always-on. The 24/7 Autonomous Agent runs locally or on Codebolt Cloud — proactive scheduling, persistent memory, plugin integrations to the messengers and APIs your business already uses. From one always-on assistant to a full autonomous company with agents managing engineering, QA, deployment, and monitoring as plugins.
The engine is a substrate, not a destination. Ship custom applications as plugins that ride inside the engine — they get memory, scheduling, multi-agent coordination, and routing for free. Or build cloud-native apps on Codebolt Cloud that share the same workspaces, sandboxes, and agent runtime your team already uses.
Same content as the section above, in an accordion-with-visual layout. Click any row to swap the panel.
Self-Improving by design. Hyper-Scaling by architecture. Most agent tools get worse with use and stop at a single environment — Codebolt's engine gets measurably better and scales to 100+ agents across machines.
Define what good looks like with eval tasks. The optimizer iterates on prompts, tools, and configs across runs and keeps the winners. Three-tier memory compounds knowledge across sessions — episodic, persistent, and a context-assembly engine that decides what each agent sees. The engine even generates new agents and plugins dynamically when the work calls for it. Agents get measurably better with use, not worse.
One agent in your terminal is the same engine that coordinates 100+ agents across local, Docker, and cloud. Proxy execution chains environments — Env A → B → C, any topology. Stigmergy gives you bio-inspired coordination: pheromone task ownership, deliberation councils, automatic review and merge — no GitHub-PR bottleneck. Coordination is built in, not bolted on.
The same engine powers every level. Start anywhere. Scale without rebuilding.
A coding agent in your terminal. One agent, full SDK.
Like Claude CodeDesktop editor with agent workspace and plugin panel.
Like CursorAlways-on agent with persistent memory and plugin integrations.
Like OpenClaw / Hermes50-100+ agents coordinated across environments.
Beyond any single toolBusiness domains as plugins. Agents coordinate across all of them.
Like Paperclip, but built-inSame engine, same SDK, same plugins — different interface for different needs.
Terminal client. Like Claude Code, but with custom agents and a growth path to multi-agent.
Learn more →Desktop editor with Monaco, agent workspace, and plugin panel. Not a fork.
Learn more →Always-on agent with persistent memory and plugin integrations. Reaches your customers wherever they are.
Learn more →Hosted engine with a browser portal. Sandbox runs, shared workspaces, no install.
Learn more →Use the Agent SDK, Plugin SDK, and Client SDK to embed Codebolt in your own product, ship agent-native apps, or run the engine headless on your infrastructure.
Extensible at every layer. Self-improving by design. Moldable at the surface.
Three SDKs. Agent SDK (63+ modules), Plugin SDK (3 channels), Client SDK (72 REST + 33 WS). The system is open at every layer.
Learn more →Remix agents (no-code YAML), Flow agents (visual graph), Custom agents (full code). 675+ skills across 72 domains. Role-specific LLM configs.
Learn more →Define what good looks like with eval tasks. The optimizer iterates on prompts, tools, and configs across runs. Your agents get measurably better with use, not worse.
Panels and plugins compose into the surface your customers see. Ship a vertical IDE, a domain-specific UI, or a SaaS — assembled from the engine's parts.
Sub-agents, parallel execution, stigmergy coordination, pheromone ownership, deliberation councils, auto review & merge — within one environment.
→ ACROSS MACHINESProxy execution chains environments. Env A → B → C. Any topology. Git bundle state transfer.
→Rust-based flight recorder. Shadow git snapshots. Per-thread history. Deterministic replay.
Policy engine with LLM risk classification. Per-role, per-environment, per-phase. Allow, deny, escalate.
Episodic + Persistent + Context Assembly Engine. Token budgets. Agents know what to remember.
"The same engine that powers a simple coding CLI also powers a 100-agent autonomous company. Everything you build — agents, plugins, memory, workflows — carries forward as you scale."
An advanced agent execution engine — from one agent to autonomous companies.
Filesystem, git, browser, terminal, LLM, vector DB, memory, knowledge graph, code search, and more.
Agent channel for work. Plugin channel for extensions. Client channel for interfaces. Each serves a distinct purpose.
OpenAI, Anthropic, Google, Mistral, Groq, DeepSeek, Ollama, LM Studio. Per-agent, per-task model selection.
Local, Docker, cloud, hierarchical. Proxy execution chains them together. Git bundles transfer state.
Bio-inspired coordination. Pheromone task ownership. Agent deliberation councils. Review & merge without GitHub PR bottleneck.
Claude Code — great CLI agent, but you can't customize the loop or scale beyond one agent
Cursor — great IDE, but agents are fixed and there's no plugin system
OpenClaw — great personal agent, but no multi-agent coordination or enterprise scaling
LangChain/CrewAI — agent frameworks, but no execution environment
Each tool is one thing. If you outgrow it, you start over.
One engine that starts as a CLI and scales to orchestrate 100+ agents
Full control over the agentic loop — write agents in code, not prompts
Plugin system with 3 communication channels — plugins run inside the platform
Multi-environment scaling across local, Docker, cloud, and hierarchical setups
Everything carries forward. Agents, plugins, memory, workflows — nothing gets rebuilt.
Every tool does one thing. Codebolt is the engine that does all of them.
| Capability | Codebolt | Claude Code | OpenClaw | Paperclip | Hermes | Letta | Cursor |
|---|---|---|---|---|---|---|---|
| What it is | Agent engine (CLI → autonomous company) | CLI coding agent | Personal AI assistant | Company orchestrator (manages agents, doesn't run them) | Self-improving agent framework | Stateful agent platform | AI-enhanced IDE |
| Runs agents | Yes — custom agents via 63-module SDK | Built-in only | Built-in only | No — orchestrates external agents | Yes — function-calling | Yes — stateful agents | Built-in only |
| Multi-agent orchestration | Yes — stigmergy, deliberation, 100+ agents | No | No | Yes — org charts, roles, budgets | No | Limited | No |
| Scales to | 1 to 100+ agents, multi-environment | 1 agent | 1 agent | Depends on agents you bring | 1 agent (subagents) | 1-10 agents | 1 agent |
| Memory system | 3-tier (episodic, persistent, context assembly) | Session only | Persistent | None | Persistent + learning loop | Persistent (core feature) | Session only |
| Plugin system | Yes — 3 channels (WS, Mux, HTTP) | Skills (limited) | Skills/integrations | Agent adapters | Skills (agentskills.io) | No | VS Code extensions |
| Surfaces | CLI + Editor + TUI + Cloud + headless | CLI + IDE extensions | Web + chat apps | Web dashboard | CLI + chat apps | CLI + API | IDE only |
| Self-improving | Yes — memory compounds, context optimizes | No | Yes — writes own skills | No | Yes — learning loop | Yes — background subagents | No |
Every capability is available at every scale — from CLI to autonomous company.
Filesystem, git, browser, terminal, LLM, vector DB, memory, knowledge graph, code search, and more.
Agent channel (codeboltjs), Plugin channel (WS + HTTP), Client channel (UI/TUI/Web). Each serves a purpose.
Local, Docker, cloud, hierarchical. State transfer via git bundles. Heartbeat monitoring. Full lifecycle management.
Policy engine with LLM risk classification. Per-agent, per-environment, per-phase scoping. Allow, deny, or escalate.
OpenAI, Anthropic, Google, Mistral, Groq, DeepSeek, Ollama, LM Studio. Per-agent, per-task model selection.
Agents review each other's work. Conflict detection. Pheromone coordination. No GitHub PR bottleneck.
The engine connects to your entire workflow through its plugin system. Native interfaces plus anything plugins can reach.
"The engine doesn't just run agents — it learns. Three-tier memory compounds knowledge across sessions. Skills improve through use. Context assembly optimizes what each agent sees. The longer you run Codebolt, the smarter it gets."
Install Codebolt. Run it in your terminal. Use a built-in agent or bring your own. Like Claude Code but with any model, full SDK access, and room to grow.
Write your first agent in 10 lines of JavaScript. Full access to 63+ SDK modules. Your logic, your tools, your rules. No other tool gives you this for free.
Switch to the desktop Editor. Install plugins that connect to GitHub, Jira, Slack. Build custom plugins. Multiple agents coordinating on your codebase.
Your agent runs always-on. Persistent memory. Proactive scheduling. Plugin integrations handle email, calendar, monitoring. Like OpenClaw, but on an engine that scales.
50+ agents across Docker and cloud environments. Stigmergy coordination. Deliberation councils. Automatic review and merge. Drift tracking. Your infrastructure, not your bottleneck.
Applications run as plugins inside the engine. Each handles a domain — engineering, testing, deployment, monitoring. Agents coordinate across all of them. You direct the vision.
Start with the CLI. Use one agent. Write custom agents when you're ready. More power than any free coding tool — because you control the agent, not just the prompt.
When two agents edit the same repo, the platform resolves conflicts. Coordination, drift tracking, and multi-environment management — so you focus on the product.
Build your company on the engine. Applications run as plugins — no separate agent instances needed. Scale across environments as you grow.
Governance, audit trails, deterministic replay, and guardrails. Every agent decision is traceable. Every change is attributable. Deploy agents in production with confidence.
Run headless in CI/CD. Spawn Docker environments. Transfer state between them. Monitor with real-time events. The engine was built for infrastructure people.
Stigmergy-based coordination. Pheromone systems. Narrative versioning. Agent deliberation councils. Research-grounded architecture with published foundations.
