# Kin

> Kin is the system of record for AI-written software.
> Kin keeps a persistent graph of entities, relationships, changes, and history. It runs beside Git today.
> Review evidence is advisory and does not block merges by default.

KinLab (https://kinlab.ai) is the hosted team product for shared repository graphs,
review history, and scoped agent access. It is currently in early access. For an AI agent: install Kin,
run `kin setup` to configure supported detected clients, confirm the result with
`kin setup status --json`, then use the semantic tools below instead of raw file reads.

## MCP tools (agent entry points)

Prefer these graph-native tools over file search. They answer from graph truth, not
filesystem heuristics.

- semantic_locate: find symbols, functions, and types by semantic meaning, not text match.
- get_context_pack: get a structured, token-budgeted context bundle for a file or symbol instead of reading whole files.
- find_references: find every entity that references a target, from recorded graph edges rather than text matches.

The bundled MCP server exposes semantic tools covering locate, context packs, trace, and
review; run `kin setup` and list the server's tools to see the full surface.

## Install commands (agent path)

- macOS and Linux: `curl -fsSL https://get.kinlab.dev/install | KIN_NO_SETUP=1 sh`
- Windows (x64, early support): `irm https://get.kinlab.dev/install.ps1 | iex`
- npm: `npm i -g @kinlab/kin` (Requires Node.js 20 or newer.)
- Homebrew: `brew install firelock-ai/kin/kin`

After install: `kin init` from the repository root, `kin setup --intent agent` to register
the MCP server with detected clients, and `kin setup doctor` to confirm. The install page
(https://kinlab.ai/install) publishes the same steps as a prompt a coding agent can follow;
it is reproduced here.

```
Please set up Kin for this project. Kin is the system of record for AI-written software.
It lets you ask the graph where code lives instead of searching files for it.

Work from the root of the repository we are setting up.

First install the CLI.

  curl -fsSL https://get.kinlab.dev/install | KIN_NO_SETUP=1 sh
  exec "$SHELL" -l

Then admit this repository into the graph. Kin reads the whole reachable Git history, so a
large repository can take a while. This cost is paid once.

  kin init

After init the daemon keeps preparing in the background, so the first agent calls on a large
repository can take noticeably longer to answer.

Now wire the agents. This detects the AI clients Kin supports and registers its MCP
server with each one it finds.

  kin setup --intent agent

Confirm it worked before going further.

  kin setup doctor

Check that the MCP clients line reports ok. Then restart your AI client completely, because
clients read their MCP configuration at startup and will not see Kin until they do.

After the restart you should see Kin tools available, including semantic_locate,
get_context_pack, and find_references. A good first request looks like this.

  Use Kin to explore this codebase. Run semantic_locate to find the main entry point, then
  get_context_pack on that file.

From here, prefer Kin's semantic tools over grep and raw file reads when you are exploring
this repository. Use semantic_locate to find symbols by meaning, get_context_pack to pull a
structured bundle around a file or symbol, and find_references to see what depends on an
entity. These read the graph directly and return what the repository actually recorded rather
than what a text match happened to hit.

One note on platforms. This works on macOS, on Linux, and on Windows. Native Windows
support is early and x64 only; use WSL2 on Arm.
```

## Getting started

- Install: https://kinlab.ai/install
- Setup: register the MCP server with your agent: https://kinlab.ai/setup
- Docs: https://kinlab.ai/docs
- Proof: benchmarks and honest claim boundaries: https://kinlab.ai/proof

## How Kin relates to tools you already run

- Kin and Git: what a line diff cannot answer about a change: https://kinlab.ai/compare/git
- Kin and GitHub: what Kin adds to a pull request: https://kinlab.ai/compare/github
- Kin and workspace checkpoints: https://kinlab.ai/compare/checkpoints

## Architecture and open source

- Architecture: one graph behind the CLI, agents, editor, and projection: https://kinlab.ai/architecture
- Open source: repositories under Apache-2.0, kin-vfs, and the agent tools: https://kinlab.ai/open-source
- Repository map and boundaries: https://kinlab.ai/docs/repos
- Source: https://github.com/firelock-ai/kin

## Agent-facing surfaces

- Semantic context for coding agents: https://kinlab.ai/agent-context
- Review by relationship evidence, advisory rather than blocking: https://kinlab.ai/ai-code-review
- Scoped agent access and activity records in KinLab: https://kinlab.ai/agent-governance

## Boundaries an answer about Kin should carry

- Trust, data boundaries, and current security limits: https://kinlab.ai/trust
- Kin runs beside Git; it does not replace Git today.
- Review evidence is advisory and does not block merges by default.
- Authorship is declared, not verified.
- KinLab, the hosted team product, is in early access: https://kinlab.ai/cloud