KinLab
Install

The diff is not the change

AI writes code faster than teams can understand its consequences.Kin shows what a change touches before it merges, by keeping a living map of the software itself.

Most AI tools rebuild context for each task. Kin keeps a durable semantic record across tasks, agents, and changes.

See a real changeInstall open-source Kin
kin impact verifySession --depth 3
changedverifySession
processCheckoutservices/checkout.tsstale call
trackUserEventservices/analytics.tsmissing arg
Promise<User>services/api_types.tsshape changed
auth.spec.tsservices/__tests__covers change

Worked example. Consequence surfaced before a compiler runs. Gaps are reported, not guessed.

See a real change

The same edit, two records.

A line diff records the edit.The graph records what the edit touches.

Standard Git diffBlind to callers
diff --git a/services/auth.ts+1 -1
- verifySession(token: string)
+ verifySession(token: string, orgId: string)

What the diff records: a one-line parameter change. Nothing here shows the sibling services still calling the old signature.

Kin semantic graphSees the consequence
EDITED ENTITY
verifySession(token, orgId)
services/auth.ts
AFFECTED CALLERS
Two callers still on the old signature
  • services/checkout.ts:84
  • services/analytics.ts:112

What Kin records: the call graph around the change, so both un-updated callers surface before the change merges.

The adoption path

Understand the change.Govern the consequence.Evolve the repository.

A diff records the edit. Kin records its consequence.

  1. 01

    Understand now

    Persistent, graph-backed context, references, traces, impact, and history for agents and reviewers.

  2. 02

    Govern next

    Advisory review first; evidence-backed gates after the organization has observed enough results to trust them.

  3. 03

    Become authority later

    Graph-native branches, transactions, merges, history, and repository state, with files and Git serving as compatibility projections.

CLI and MCP

Ask the graph from any surface.

Query exact context from your terminal, or serve the same graph to Claude, Cursor, and Codex over MCP.

kinExample output
~/my-repo $ kin impact verifySession --depth 3
Impact analysis for 'verifySession' (Function) @ services/auth.ts:42:
  4 local entities impacted within 3 hops:
  1 hop (direct callers):
    - processCheckout (Function) @ services/checkout.ts:84
    - trackUserEvent (Function) @ services/analytics.ts:112
  2 hops:
    - checkoutRoute (Function) @ api/routes/checkout.ts:31
    - verifySession contract (Test) @ services/__tests__/auth.spec.ts:12
What Kin is, and is not

The graph is the record, not an index over it.

Kin is not another context engine or code reviewer. It is the system of record for AI-written software, and the graph is where that record lives.

  1. 01

    Not another context engine

    Context is one output of the standing graph.

  2. 02

    Not another AI reviewer

    Review is one decision surface over the record the graph already holds.

  3. 03

    Not a graph over Git

    That describes an index. Kin's thesis is that the graph itself becomes durable repository truth.

Evidence

AI writes code.Kin proves what changed.

On a real ripgrep change, a one-line signature edit surfaces the entities it affects before a compiler runs. The exact reproduction commands, and the limits of what we claim, are on the evidence page.

One line changed.Consequence surfaced before compilation.

A pinned revision, the reproduction recipe, and the claims we are not making.

Inspect the evidence
KinLab for teams

Bring the shared record to your entire team.

KinLab adds shared repository graphs, review history, and team memory on top of Kin.

Request KinLab accessExplore enterprise fit

Start with one repository.

Install Kin locally, initialize one repository, and give your agents exact context from a standing semantic graph.

Install Kin