The diff is not the change.

Git hosts files and preserves history everywhere software ships. However, Git records code as flat text lines, leaving all architectural relationships implicit. Kin runs beside Git to track the actual dependencies, keeping agents and reviewers aligned on reality.

Install Kin See the comparison

The core thesis

Why flat diffs limit AI

When an agent receives only a flat diff, it can't determine if a changed parameter broke 3 callers, 10 callers, or none. It has to blindly search files or guess imports. Kin solves this by providing a standing, queryable graph.

Line-based and graph-backed, side by side

Traditional approach

Line-Based Git

Git parses files byte-by-byte. A diff tells you that line 12 inside utils.go was modified. It has no native concept that this line represents a function ParsePayload(), nor does it know what files call this function. The system relies on developers or agents running global compilation or full-workspace searches to trace connections.

Kin approach

Semantic-Graph Kin

Kin indexes abstract syntax trees (ASTs) to preserve codebase topology. When a change occurs, Kin maps it to a named entity ParsePayload() and immediately traces all caller nodes. Your agent doesn't need to read hundreds of irrelevant files to find what broke; Kin packages the exact dependencies and serves them cleanly over MCP.

Architecture Matrix

Kin vs. Git Feature Breakdown

Review how line-based Git compares directly with the semantic capabilities of Kin across five core architectural dimensions.

Swipe sideways to compare

Comparison Axis	Git (Line-Based Diff)	Kin (Semantic Graph)
Canonical Authority The underlying system of record	Files and commits are the only truth. Relationships are implicit and must be parsed out of the file tree on every run.	The semantic dependency graph is the durable authority. Code files and Git histories are projected as compatible views from this graph.
Git stays. Kin reads its history structurally, so code dependencies stay queryable at every commit.
Context Retrieval Finding relevant dependencies	Manual file searching, simple grep, or static LSP indexing. No awareness of semantic consequence or multi-hop dependencies.	Graph-backed trace, locate, and context-pack retrieval. Pulls exact multi-hop dependent entities from the standing graph.
A targeted context pack replaces bulk file loading, so the agent's context window carries evidence instead of guesswork.
Agent Hallucinations Mitigating agent API errors	High risk. Agents lack visibility into downstream impact, prompting blind changes to out-of-context signatures or APIs.	The graph keeps explicit entity boundaries and relationship traces, and agents and reviewers get strict evidence.
Signatures and types live in the record, and Kin checks caller references as an agent edits, before anything reaches CI.
Multi-Agent Merges Merging concurrent modifications	Textual merge conflicts are common and hard to resolve for agents. No semantic merge verification.	Graph-native branches, transactions, and semantic merges. Conflicts are resolved at the structural/entity level, preventing compile-time breaks.
Structural merges catch compile-time breaks at merge time instead of letting them fail silently on main.
Tool Coexistence Integration with existing pipelines	Universal standard, but limits developer tools to line-based changes.	Coexists beside Git, CI/CD, and existing dev environments. Exposes local graph tools via MCP for any AI client (Cursor, Claude, Codex).
Your CI configs and hosting stay untouched. Install the CLI locally and run it beside git.

Click on any comparison row to expand technical details and architecture breakdowns.