Code intelligence for your coding agent.

Before your agent changes code, CKB tells it what can break.

CKB runs underneath Claude Code, Cursor, Windsurf, VS Code and other supported agents, so your agent stops guessing how your code fits together.

Not another AI coding tool. The code intelligence layer your agents use.

1Install CKB in your repo

→

2Connect your agent (Claude Code, Cursor, …)

→

3Keep coding

Show the commands

npm install -g @tastehub/ckb
ckb init
ckb index
ckb setup

Or via Homebrew: brew install SimplyLiz/ckb/ckb

Get Started Free Documentation

Free for personal use. No credit card required.

ckb

Runs entirely on your machine — no code leaves it

Available via MCP, CLI, HTTP API or as a background daemon

Set up in a few commands

Works with what you already use

You keep your agent.

CKB doesn't replace Claude Code, Cursor, Windsurf, VS Code and other supported agents. It runs underneath, quietly giving your agent real knowledge of your codebase.

No second assistant, no new workflow, nothing new to learn.

The difference

Without CKB, your agent guesses. With CKB, it knows.

Left: your agent searches, reads files, searches again, and infers. Right: it asks a question and gets back the actual structure of your code — who calls what, what tests exist, who owns it.

without ckb

$search
→read
→search
→infer
→guess

with ckb

$task
→CKB gathers structural evidence
→agent acts

See how CKB gathers evidence

In practice

You say → your agent knows.

Three everyday asks. Ask your agent to use CKB, or add it to your agent's instructions, so it gathers evidence instead of guessing.

“Refactor the login flow to use the new session token format.”

Before touching code, your agent pulls every caller, test, and contract touching the auth flow, so it doesn't refactor blind.

“Why does changing this type break the API?”

Your agent traces the type through every function signature and consumer that depends on it, and surfaces the exact breaking points.

Excerpt of real output (findReferences — changed symbol)

$ ckb refs <symbol-id for Engine#buildProvenance>

Total references: 27

By Module:
  internal/query/breaking.go: 1 references
  internal/query/compound_refactor.go: 1 references
  internal/query/cycles.go: 1 references
  internal/query/impact.go: 3 references
  internal/query/ownership.go: 1 references
  internal/query/suggest.go: 1 references
  internal/query/compound.go: 5 references
  internal/query/deadcode.go: 1 references
  internal/query/engine.go: 1 references
  internal/query/responsibilities.go: 1 references
  internal/query/symbols.go: 7 references
  internal/query/unwired.go: 1 references
  internal/query/architecture.go: 3 references

References:
  1. internal/query/architecture.go:362 (read)
  2. internal/query/architecture.go:437 (read)
  3. internal/query/architecture.go:490 (read)
  4. internal/query/breaking.go:91 (read)
  5. internal/query/compound.go:318 (read)
  …

“Review this PR.”

Your agent gets structural findings — breaking changes, dead code, test gaps, secrets — instead of re-reading every file from scratch.

See more examples

Scale

CKB reads more so your model reads less.

CKB indexes your codebase ahead of time. Your agent only sees what's relevant to the task.

When your agent needs an answer, it gets the callers, tests and owners that matter, not a pile of files to read.

Repository

Your full codebase.

CKB traverses structural knowledge

Indexed ahead of time — symbols, callers, tests, owners.

Agent receives only relevant evidence

The slice that matters for this task, not the whole codebase.

In our example, CKB's answer was 137× smaller than the source files it points to (bytes, one query on the CKB repo).

Under the hood

110 capabilities. Nothing to learn.

Your agent can expand its capability set when a task needs more — starting from a core set of 25, up to 110 total.

CKB ships 25 core capabilities by default. When a task calls for more, your agent can expand its access — up to 110 total.

See all capabilities

25core, always on

can expand on demand

How it knows

Evidence, not guesses.

CKB doesn't guess from embeddings. It reads your code the way a compiler and your version control already do.

CKB draws from a compiler-grade symbol index, your language servers, your git history, and structural analysis of the code itself. CKB never modifies your source code — a few capabilities record knowledge (decisions, annotations) in CKB's own store, never in your codebase.

Symbol index

Language servers

Git history

Structural analysis

See how it works

Case study

One PR. Measured, not modeled.

We ran the same 133-file pull request through Claude Opus 4.6 twice — once without CKB, once with it.

Without CKB: 87,336 tokens, 4 findings. With CKB: 45,784 tokens (−48%), 33 findings, 15 structural checks in 5.2 seconds. Measured once, on one PR in our CI — not an average across repos.

Metric

Without CKB

With CKB

Tokens

87,336

45,784 (−48%)

Findings

Checks run

—

Wall-clock time

—

5.2s

Measured on one 133-file PR in our CI. We don't yet have a public, reproducible multi-repo benchmark — that's a real gap, not a rounding error.

How the code review works

Beyond the agent

For power users.

Run it from the command line, wire it into CI, call it over HTTP, or check compliance before you ship.

CLI CI review HTTP API A2A protocol Federation Compliance pre-check

Roadmap — not shipped

Where CKB is going.

Today your agent asks CKB questions one at a time. Next, CKB will check what your agent's changes actually touched and keep a local record of what it asked and got back. Later, your agent will state what it's about to do and CKB will assemble the evidence itself.

See the roadmap