Skip to main content

What is Codebolt

Codebolt is an AI-native coding environment. You can use it the way you'd use a traditional editor — open a project, chat with an AI, let it make changes, review, commit — or you can push much further, running swarms of specialised agents that plan, execute, review, and merge changes across a codebase while you watch.

The short version​

  • For end users — a desktop app (with a CLI and TUI companion) that lets you work with AI agents on real projects. Think of it as an editor where "run an agent" is as first-class as "open a file".
  • For developers — an extensible agent runtime. Every piece is designed to be replaced: custom agents, custom tools, custom providers, custom orchestration, custom memory. The server is open for you to build on.
  • For teams — a self-hostable server with full audit trails, guardrails, human-in-the-loop review, and a marketplace of agents and tools.

What makes it different​

A lot of "AI coding tools" are an autocomplete plus a chat box. Codebolt is a different shape:

  1. Agents are real processes, not loops. Each agent runs in its own OS process, supervised by a process manager, with heartbeats and restart policies. Crashes are contained. Long-running work is durable.

  2. Multi-layer memory, not "a context window". Working memory, episodic memory, persistent memory, KV store, knowledge graph (Kuzu), vector DB, narrative threads — with a context assembler that picks what goes into the prompt. See Memory.

  3. Shadow git. Every agent edit is committed to a parallel git repo automatically, so you can roll back any change instantly without touching your real git history. See Checkpoints.

  4. Guardrails as a sidecar. Rule-based and LLM-based checks run before every tool call. See Guardrails.

  5. Multi-agent is first-class. Swarms, agent flows, roles, teams, plan-execute-review, debate, stigmergy — all supported, with a graph runtime and a full event log. See Multi-Agent Orchestration.

  6. Everything is replayable. The event log is the authoritative causal record. You can replay any run, audit any decision, query the history. See Persistence & Event Log.

What you can do with it​

Quick sampling, from easiest to most ambitious:

  • Chat-assisted editing. Open a project, talk to an agent, let it make changes with checkpoints so you can undo anything.
  • Task delegation. Hand an agent a concrete task ("add a rate limiter to this endpoint, write tests"), walk away, come back to a reviewable diff.
  • Custom agents. Build an agent specialised for your codebase — your coding conventions, your internal APIs, your review standards. See Build Agents.
  • Custom tools. Write an MCP server that gives agents access to your internal systems. See MCP Tools.
  • Multi-agent workflows. Set up a plan-execute-review flow for high-risk changes, or a map-reduce for embarrassingly parallel work. See Multi-Agent Orchestration.
  • Self-hosting for a team. Run the server yourself, with shared memory, guardrails, and audit trails across your organisation. See Self-Hosting.

What it is NOT​

So you don't build the wrong mental model:

  • Not an autocomplete. There is inline edit (Ctrl+K), but the core unit is an agent run, not a keystroke completion.
  • Not cloud-locked. Local models work. Self-hosting works. Your code doesn't have to leave your machine.
  • Not magic. Agents make mistakes, hit dead ends, and produce bad code just like humans. The design assumption is that you review the output, not that you don't have to.

Where to next​