# Kin

> A new foundation for code.
> Kin is an open-source code repository for people and AI agents. It versions code and recorded relationships together.
> Give people a clearer basis for directing and reviewing AI-driven work. Kin supports graph-native repositories and migration from Git.
> Review evidence is advisory and does not block merges by default.
> Current stage: Public alpha, open source under Apache-2.0.

KinLab (https://kinlab.ai) is the hosted team product for shared repository graphs,
review history, and scoped agent access. It is currently in development. 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.

## Where to go

- [Developers](https://kinlab.ai/developers): understand the local product and choose a workflow.
- [Documentation](https://kinlab.ai/docs): start here for a small, checkable quickstart and links to the reference.
- [Install Kin](https://kinlab.ai/install): platform instructions and supported installation paths.
- [Connect an agent](https://kinlab.ai/docs/reference/mcp): MCP setup and reference.
- [Query your code](https://kinlab.ai/docs/agents): examples of finding code and inspecting recorded connections.
- [Written product example](https://kinlab.ai/examples/react-callers): a dated written example with saved command output and limits. It is not a video or screen recording. The homepage figures come from saved runs and name their Kin version.
- [KinLab for teams](https://kinlab.ai/cloud): the hosted product in development and the early-access request path.
- [Design partners](https://kinlab.ai/design-partners): propose a real workflow for a scoped evaluation.
- [Investors](https://kinlab.ai/investors): company and investment context. Intended outcomes are not achieved results.

## 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 recorded references to a target. Connections can be incomplete; check coverage and important results against code.

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)

Start with the primary command. It installs Kin and registers the MCP server with every AI
client on the machine, and it is the same on macOS, Linux, Windows and WSL.

- Every platform, needs Node 20 or newer: `npx -y @kinlab/kin setup --intent agent --no-interactive`

Other ways in, for a machine without Node or a team that prefers a package manager. Run
`kin setup --intent agent` after any of these to register the MCP server.

- 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`

Kin lands in ~/.kin/bin and the install adds that directory to the shell profile, so open a
new login shell before calling `kin` by bare name. Then `kin init` from the repository
root, 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.

On a small repository, a fast kin init can outrun the 523 MB embedding model download in the background, so the first kin locate may run without semantic ranking; run it again after the download finishes.

```
Please set up Kin for this project. Kin records named code, resolved relationships and changes as repository data, with familiar files available to supported tools.
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 Kin and connect the AI clients on this machine. One command does both, and it
is the same on macOS, Linux, Windows and WSL. It needs Node 20 or newer.

  npx -y @kinlab/kin setup --intent agent --no-interactive

If this machine has no Node, use the installer instead. It puts the same binaries in the same
place.

  curl -fsSL https://get.kinlab.dev/install | KIN_NO_SETUP=1 sh

Either way Kin lands in ~/.kin/bin and adds that directory to your shell profile, so start a
new login shell before you use the bare name.

  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.

Some clients record the repository they answer for, so run setup once more from inside the
initialized repository to pick those up.

  kin setup --intent agent

Confirm it worked before going further.

  kin setup doctor

Check that the MCP clients line reports ok.

Now install the language servers. Kin resolves references across files through a language
server for each language in the repository, and a fresh host usually has none, so do this
before you rely on find_references.

  kin doctor --fix --install-language-servers

Kin uses a toolchain you already have when there is one, and otherwise downloads a release
binary it checks against a digest it ships with. It prints what it installed and where it came
from, and it tells you when the server it installed still needs something Kin will not install
for you. Rust is the case worth knowing: rust-analyzer reads a project by running cargo, so on
a machine with no Rust toolchain it starts and resolves nothing, and Kin says so. If it reports
that it could not finish, keep going. Everything else works, and Kin reports reference edges as
pending for that language rather than telling you a symbol has no callers.

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. find_references answers for a language only once its
language server is installed, which is what the step above is for. 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): the install commands and what each one puts on your machine.
- [Setup](https://kinlab.ai/setup): register the MCP server with your coding agent.
- [Docs](https://kinlab.ai/docs): from install to a useful answer.
- [Proof](https://kinlab.ai/proof): benchmarks and honest claim boundaries, including where Kin only ties.
- [Proof case: hiredis on v0.7.4](https://kinlab.ai/proof/cases/hiredis-v074): one dated run against a published release archive, with each finding linked to the receipt behind it and a list of what the run did not record.
- [Proof methodology](https://kinlab.ai/proof/methodology): the rules a case follows before it ships, and what "not recorded" means on these pages.
- [Proof archive](https://kinlab.ai/proof/archive): dated cases, the older benchmark kept where it is, and the artifact paths older results were cited by.
- [Changelog](https://kinlab.ai/changelog): what has shipped so far. For the version a user installs today, run `npm view @kinlab/kin version`.

## How Kin relates to tools you already run

- [Kin and Git](https://kinlab.ai/compare/git): what a line diff cannot answer about a change.
- [Kin and GitHub](https://kinlab.ai/compare/github): what Kin adds to a pull request.
- [Kin and workspace checkpoints](https://kinlab.ai/docs/architecture#history-and-checkpoints): what a snapshot restore does not know.

## Architecture and open source

- [Architecture](https://kinlab.ai/docs/architecture): one graph behind the CLI, agents, editor, and projection.
- [Open source](https://kinlab.ai/open-source): repositories under Apache-2.0, kin-vfs, and the agent tools.
- [Repository map](https://kinlab.ai/docs/repos): every repository and the boundary it owns.
- [Source](https://github.com/firelock-ai/kin): the Kin repository on GitHub.

The Kin CLI and its libraries are open source under Apache-2.0; hosted KinLab is
in development. Team access can be requested for a scoped evaluation.

## Agent-facing surfaces

- [Semantic context for coding agents](https://kinlab.ai/docs/agents): the MCP tools an agent calls instead of reading files.
- [AI code review](https://kinlab.ai/docs/workflows/impact): review by relationship evidence, advisory rather than blocking.
- [Agent governance](https://kinlab.ai/enterprise): scoped agent access and activity records in KinLab.
- [Code change impact analysis](https://kinlab.ai/docs/workflows/impact): what a change touches, before a build runs.
- [Find recorded callers of a function](https://kinlab.ai/docs/workflows/impact): from recorded graph edges rather than text matches.

## Boundaries an answer about Kin should carry

- [Trust](https://kinlab.ai/trust): data boundaries and current security limits.
- Git coexistence is an adoption path. Language coverage and workflow support are limited.
- Review evidence is advisory and does not block merges by default.
- Authorship is declared, not verified.
- KinLab, the hosted team product, is in development: [KinLab for teams](https://kinlab.ai/cloud).

## Who builds it

- [About](https://kinlab.ai/about): Firelock, LLC builds Kin and KinLab.
- [Firelock on GitHub](https://github.com/firelock-ai): the organization that publishes every repository above.

## Optional

- [Careers](https://kinlab.ai/careers): working on Kin.
- [Terms](https://kinlab.ai/terms): terms of service.
- [Privacy](https://kinlab.ai/privacy): the privacy summary.

## Writing

- [Blog](https://kinlab.ai/blog): engineering notes from building Kin.
- [Feed](https://kinlab.ai/rss.xml): the same posts as RSS.
- [Before you change code, check what uses it](https://kinlab.ai/blog/check-react-callers-against-source): A written React example shows how to check the connections behind a code change, with the commands and source available when you want the detail.
- [Introducing Kin: Software, beyond files.](https://kinlab.ai/blog/the-repo-is-a-graph-not-files): Meet Kin, a code repository that versions the connections, not just the code. See how keeping code connections together can help with the next change.
- [The check that passed because it measured nothing](https://kinlab.ai/blog/checks-that-cannot-fail): Six checks that reported success while measuring nothing, the command that reproduces each one, and the habit that catches the rest before it costs you.
- [Your code search says nothing uses it. Can you delete it?](https://kinlab.ai/blog/empty-answer-safe-to-delete): An empty search answer can hide missing information. Learn what to check before treating code as unused.