An advanced agent execution engine. As simple as a coding CLI. As powerful as autonomous company infrastructure.
Codebolt is not an agent — it's the engine that runs agents. Not a framework — it's the execution environment where agents, plugins, and applications operate. Every other tool is one thing. Codebolt is the engine that becomes what you need.
Agents connect through the Agent SDK. Plugins extend through the Plugin SDK. Interfaces connect through the Client SDK. All three channels meet at the engine core.
Other tools operate at Layer 1-2. Agent frameworks at Layer 2. Codebolt is all five layers — a complete engine.
Extend the engine itself. Write custom agents with the 63-module SDK. Build plugins with 3 communication channels. Create custom clients with 72 REST APIs + 33 WebSocket modules. The system is open at every layer.
Make any agent more powerful. Remix agents inherit and customize without code. Add skills from 675+ tools. Flow-based visual composition. Role-specific LLM configs. Capability declarations. Every agent is extensible.
Within a single environment, agents spawn sub-agents, run parallel child threads, coordinate via stigmergy and pheromones, hold deliberation councils, and review each other's work. From 1 to 100+ agents.
Across machines: proxy execution chains environments together. Env A calls Env B calls Env C. Providers bridge via WebSocket. Git bundles transfer state. Heartbeat monitoring. Hierarchical or peer-to-peer.
Three SDKs. Three extension points. Complete control over the engine.
Write agents in JavaScript with 63+ SDK modules — filesystem, git, browser, terminal, LLM, vector DB, memory, knowledge graphs. Full control over the agentic loop.
Three communication channels — WebSocket actions, multiplexed events, HTTP REST. Plugins run inside the engine. No separate agent instance needed.
72 REST API modules + 33 WebSocket modules. Build dashboards, mobile apps, Slack bots, VS Code extensions — anything that talks to the engine.
Multiple ways to make agents more powerful — from no-code to full code.
Remix Agents inherit from a base agent and add custom instructions in YAML+Markdown — no code required, git-friendly, composable. Flow Agents use a visual graph editor (LiteGraph) for drag-and-drop agent workflows. Custom Agents are pure code with full SDK access. Remote Agents run in external environments. All types share the same 675+ skill library.
Remix Agent (no-code):
---
baseAgent: code-gen
supportedlanguages: [python]
---
Custom instructions here...
Flow Agent (visual):
[Node A] → [Node B] → [Node C]
Custom Agent (full code):
codebolt.onMessage(async (msg) => {
// your logic, your tools
});
Agents access skills organized across 72 tool domains — file operations, git, browser control, terminal, LLM, vector database, agent control, memory, knowledge graphs, and more. Skills are scoped by environment capabilities — the engine prevents agents from calling unavailable tools. Add skills, declare capabilities, set per-agent model preferences.
72 tool domains:
├─ file (read, write, search, diff)
├─ git (commit, push, branch, merge)
├─ browser (navigate, click, screenshot)
├─ terminal (execute, stream, PTY)
├─ llm (chat, embed, count tokens)
├─ vectordb (store, query, search)
├─ agent (start, stop, list, spawn)
├─ memory (persist, retrieve, graph)
└─ ... 64 more domains
= 675+ individual tools
Sub-agents, parallel execution, stigmergy, deliberation, and review — all within a single Codebolt instance.
An agent can spawn background child threads that run in parallel. Parent agents wait for individual completions, grouped completions, or any external event. Children are full agent instances with complete SDK access — not async tasks. Group multiple children and await batch completion. Message-driven communication between parent and children.
Parent Agent
├─ spawn → Child 1 (review)
├─ spawn → Child 2 (test)
├─ spawn → Child 3 (docs)
│
└─ waitForGroup('batch-1')
↓
All children complete
→ Merge results
→ Continue
Agents coordinate through shared state (stigmergy), not fragile message passing. Pheromone-based task ownership prevents conflicts. Deliberation councils let agents propose, debate, vote, and reach consensus. The review-merge system lets agents review each other's work and auto-merge without GitHub PR bottleneck. Drift tracking catches deviation across all agents.
Agent A: implements feature
Agent B: reviews (auto-assigned)
Agent C: checks for drift
↓
Deliberation if conflict
↓
Auto-merged. Traced. Auditable.
No human bottleneck.
One environment's agent can trigger work in another. Chain them. Scale them. Any topology.
The RemoteExecutionPlugin bridges environments via WebSocket. Environment A's agent sends work to Environment B, which can forward to Environment C. Any topology — linear chains, trees, peer-to-peer. Each environment runs its own Codebolt instance with full capabilities. The proxy is plugin-based — not hardcoded — so any environment can claim the execution gateway.
Env A (laptop)
│ proxy execution
↓
Env B (Docker GPU)
│ proxy execution
↓
Env C (cloud cluster)
Or: Env A ↔ Env B ↔ Env C (peer)
Or: Env A → [Env B, Env C, Env D] (fan-out)
Any topology. Plugin-based routing.
Git bundles transfer workspace state between environments. The Narrative Engine snapshots per-environment with per-thread git refs. Full lifecycle management — CREATED, STARTING, RUNNING, STOPPING, STOPPED — with heartbeat monitoring every 30 seconds. The provider system treats local, Docker, cloud, and hierarchical environments identically.
Environment Lifecycle:
CREATED → STARTING → RUNNING
↕ heartbeat (30s)
STOPPING ← STOPPED ← ERROR
State Transfer:
Env A [snapshot] → git bundle
→ Env B [restore]
Bidirectional. Any topology.
A Rust-based flight recorder capturing the full reasoning chain for every agent action. Shadow git for snapshot versioning. Per-thread commit history. Agent attribution for every change. Git bundle export for cross-environment transfer. Deterministic replay of any decision point. 12 snapshot operations including create, browse, merge, checkout, import/export.
Local Rust engine instances assess drift within each agent context — structural, scope, constraint, and coverage drift. The global JavaScript coordination layer aggregates signals across all agents, detecting systemic drift that no single agent would catch. When agents deviate from intent, the system flags it before it compounds.
The policy engine evaluates agent actions against configurable rules. Scoped by agent role, agent ID, environment, provider, and execution phase. LLM-based risk classification. Decisions: allow, deny, or escalate to human. Every decision logged for audit.
Episodic memory for time-based recall. Persistent memory with chunking, embedding, and retrieval pipelines. The Context Assembly Engine assembles optimal context from all memory types using rules, pipelines, and token budgets. Agents know what to remember and when.
The engine never calls platform APIs directly. It defines a HostBridge interface for process spawning, SQLite, Kuzu graph DB, and ONNX inference. Each runtime implements its own bridge: Electron uses UtilityProcess, CLI uses child_process and better-sqlite3, TUI connects via WebSocket proxy. One codebase, every runtime.