kin v0.6.4

subgraph surfaces["Access surfaces"]
    cli["kin CLI"]
    mcp["Kin MCP server"]
    editor["kin-editor for VS Code"]
end

daemon["kin daemon"]
authority["Graph authority<br/>entities, relations, changes, provenance"]
db["kin-db<br/>graph storage, snapshots,<br/>index, text and vector search"]
prims["kin-model, kin-blobs, kin-search,<br/>kin-vector, kin-infer, kin-lsp"]
vfs["kin-vfs<br/>transparent file projection"]
tools["Editors, compilers, build systems"]
git["Git<br/>import and export boundary"]
kinlab["KinLab<br/>hosted collaboration and control plane"]

people --> cli
people --> mcp
people --> editor
cli --> daemon
mcp --> daemon
editor --> daemon
daemon --> authority
authority --> db
db --> prims
authority <-->|"kin init imports, kin git export"| git
authority -->|"publish and sync"| kinlab
authority --> vfs
vfs --> tools

Unter diesen Oberflächen liegen die Schichten, aus denen das System aufgebaut ist:

| Schicht | Rolle |
| --- | --- |
| **[kin-db](https://github.com/firelock-ai/kin-db)** | Graph-Speicher, Snapshots, Indizierung, Textsuche und Vektorsuche. |
| **[kin-model](https://github.com/firelock-ai/kin-model)** | Kanonische Typen und Domänenmodelle, die über den gesamten Stack geteilt werden. |
| **[kin-blobs](https://github.com/firelock-ai/kin-blobs)** | Inhaltsadressierbarer Blob-Speicher. |
| **[kin-search](https://github.com/firelock-ai/kin-search)** | Lexikalische Suchprimitive und gestufte Abfrage. |
| **[kin-vector](https://github.com/firelock-ai/kin-vector)** | Vektor- und Nächste-Nachbarn-Substrat. |
| **[kin-infer](https://github.com/firelock-ai/kin-infer)** | Inferenz- und Einbettungs-Substrat. |
| **[kin-lsp](https://github.com/firelock-ai/kin-lsp)** | Language-Server-Anreicherung, die die semantische Schicht speist. |

Dies sind Implementierungsschichten eines einzigen Systems, keine separaten Produkte, die ein neuer
Benutzer zusammensetzen muss. Keines davon wird separat installiert.

## Open Source und das Kin-Ökosystem

Der Kern von Kin ist unter Apache-2.0 Open Source: [kin](https://github.com/firelock-ai/kin),
[kin-db](https://github.com/firelock-ai/kin-db), [kin-vfs](https://github.com/firelock-ai/kin-vfs),
und [kin-editor](https://github.com/firelock-ai/kin-editor), plus die unterstützenden
Bibliotheken kin-model, kin-blobs, kin-search, kin-vector, kin-infer, kin-lsp und
kin-actions.

[KinLab](https://kinlab.ai) ist ein proprietäres Produkt, das auf diesem offenen Kern aufbaut: die
gehostete Kollaborations- und Control-Plane-Ebene, die oben beschrieben wurde.

Dieselbe Grenze gilt dafür, wie Benchmark-Arbeit geteilt wird. Die [Benchmark-
Spezifikation und ein eigenständiger, abhängigkeitsfreier Bundle-Verifizierer](https://github.com/firelock-ai/kin-bench-spec)
sind öffentlich, sodass eine Behauptung ohne Zugriff auf das System, das sie erzeugt
hat, überprüft werden kann. Die Runner- und Beweis-Infrastruktur, die versiegelte Beweis-Bundles erzeugt (die
Orchestrierung, das Proof-Gate für festgelegte Releases und die gehostete Messumgebung)
bleiben vorerst privat. Die Spezifikation und der Verifizierer öffnen zuerst; der Runner
kann später öffnen.

## Kürzester graphgestützter Pfad

Fünf Befehle, und der letzte ist die Antwort:```sh
curl -fsSL https://get.kinlab.dev/install | sh
exec "$SHELL" -l
cd /path/to/your/repository
kin init .
kin locate "where are webhook retries handled"

Verwende `kin setup --intent editor` für den VS-Code-Pfad. Bestätige die resultierende
maschinenlesbare Health-Checkliste mit `kin setup status --json`.

Der Installer löst die [neueste stabile Version](https://github.com/firelock-ai/kin/releases/latest) auf,
verifiziert deren veröffentlichte SHA-256-Prüfsumme, installiert die verwalteten Binärdateien unter
`~/.kin` und startet das Setup. Die Ausführung der expliziten `agent`-Absicht konfiguriert den
integrierten MCP-Server für erkannte unterstützte Clients. Verwende `--intent local` für die CLI-
und Dateisystemnutzung ohne MCP-Konfiguration oder `--intent editor` für den VS-
Code-Pfad.

Um nur setup-verwaltete Integrationen zu entfernen, führe `kin setup uninstall` aus. Für das
standardmäßige verwaltete Root-Verzeichnis (`~/.kin`) stoppt `kin setup uninstall --all` auch alle Kin-
Daemons, entfernt exakte Legacy-Installer-PATH-Blöcke und löscht rekursiv die verwaltete
Installation (`--dry-run` zeigt eine Vorschau). Ein benutzerdefiniertes `KIN_HOME` wird niemals rekursiv
entfernt: Führe zuerst die auf das Ledger beschränkte Deinstallation aus und überprüfe und entferne dann
dieses Verzeichnis explizit. Geänderte, zum Setup gehörende Slices blockieren eine vollständige Entfernung,
sofern du nicht `--force` hinzufügst, sodass die Deinstallation niemals stillschweigend eine vom Benutzer
bearbeitete Client- oder Shell-Konfiguration überschreibt. Unter Windows plant die CLI ihr gesperrtes
Installationsverzeichnis zur Löschung unmittelbar nach Beendigung des laufenden Prozesses. Windows behält
absichtlich eine inerte, nur für den aktuellen Benutzer gültige Sidecar-Autorität bei; die Stabilität dieser
Sperridentität zu erhalten verhindert, dass ein Absturz oder eine gleichzeitige zukünftige Installation zwei
unabhängige Mutationsautoritäten erzeugt. Die CLI und das JSON-Ergebnis legen diese beibehaltenen
Koordinierungsmetadaten offen, anstatt null verbleibende Bytes zu behaupten.

Für die manuelle Installation werden jedes Archiv und seine `.sha256`-Datei unter
`https://github.com/firelock-ai/kin/releases/latest/download/` veröffentlicht. Die sich ändernden
Asset-Namen sind `kin-macos-aarch64`, `kin-macos-x86_64`, `kin-linux-aarch64`,
`kin-linux-x86_64` und `kin-windows-x86_64`; verwende das Suffix `.tar.gz` für die
macOS- und Linux-Archive und das Suffix `.zip` für Windows, wie auf der
Seite der neuesten Version gezeigt. Das Windows-Zip ist auch das, was der PowerShell-Installer und
der npm-Launcher abrufen.

Der npm-Einstiegspunkt löst denselben öffentlichen Release-Kanal auf:```sh
npm install -g @kinlab/kin@latest

Ein Benutzer-Präfix liegt auf dem `PATH` Ihrer interaktiven Shell und sonst nirgendwo. Skripte, CI-Schritte,
`docker exec` und Agent-Clients erben ihn nicht. Geben Sie diesen daher den absoluten Pfad zur
Binärdatei anstelle eines nackten `kin`. Siehe
[Funktioniert mit Ihrem Agenten](#works-with-your-agent) für die Registrierungsform.

Ein Homebrew-Tap verfolgt denselben Release-Kanal:```sh
brew install firelock-ai/kin/kin

In einem erkannten Git-Repository nimmt `kin init` atomar die vollständige erreichbare Historie, Refs, Rohobjekte, den exakten Workspace-Baum und die Aufnahmerichtlinie in die repository-v6-Graphautorität auf. Ein Worktree mit nicht committeten Änderungen, gestagten Änderungen oder nicht verfolgten Dateien wird trotzdem aufgenommen: `kin init` nimmt den committeten Zustand auf und legt offen, was es nicht aufgenommen hat. Es ersetzt niemals einen exakten HEAD-Snapshot oder einen semantischen Rohdateisystem-Rebuild. Unterstützte repository-lokale Remote-URLs, Refspecs, Branch-Tracking und Push-Standardwerte werden in Kins Git-Koexistenzkonfiguration versiegelt; unsichere, mehrdeutige oder nicht unterstützte Übertragungseinstellungen schlagen vor der Veröffentlichung fehl (fail closed).

Die Aufnahme leitet außerdem die semantische Entitäts- und Beziehungsebene für jede unterstützte Entitätsquellendatei in dieser Historie ab, und `kin init` meldet die dauerhaften, generationsgebundenen Zählwerte, die es committet hat. `kin status` meldet diese Repository-Autoritätssicht; `kin graph status` meldet separat den veränderlichen Live-Abfragegraphen des Daemons, der später abgeleitete Anreicherungen enthalten kann.
Abfrageoberflächen konsumieren graph-eigene Anreicherungen, wenn sie vorhanden sind, und melden deren Fehlen, anstatt die Lücke hinter einer Rohdateisuche zu verbergen.

#### Welche Dateien zu Entitäten werden

„Unterstützte Entitätsquellendatei“ bedeutet eine Datei, die einer von Kins Sprachadaptern beansprucht. Die Adapterregistrierung ist die gesamte Menge, und jede Datei in einem Repository wird über sie aufgelöst:

| Sprache | Erweiterungen |
| --- | --- |
| TypeScript | `.ts`, `.tsx` |
| JavaScript | `.js`, `.jsx`, `.mjs`, `.cjs` |
| Python | `.py`, `.pyi` |
| Go | `.go` |
| Java | `.java` |
| Rust | `.rs` |
| C | `.c`, `.h` |
| C++ | `.cpp`, `.hpp`, `.cc`, `.cxx` |
| C# | `.cs` |
| Ruby | `.rb` |
| PHP | `.php` |
| Swift | `.swift` |
| Kotlin | `.kt`, `.kts` |
| HCL / Terraform | `.tf`, `.tfvars` |

Eine `.h`-Headerdatei wird als C++ gelesen, wenn ihr Inhalt dies sagt, sodass ein C++-Projekt Namespaces und Templates nicht an die C-Grammatik verliert.

Alles andere wird als Inhalt aufgenommen und bleibt als Historie und Text abfragbar, wird aber nicht in Entitäten und Beziehungen geparst. Dazu gehören Markdown, HTML und CSS, SQL, YAML, JSON und TOML, Shell-Skripte, Objective-C, Scala, Elixir, Dart, Lua, R, Zig, Haskell und Nix. Wenn Ihre Sprache auf dieser Liste steht, finden `locate` und `refs` darin keine Symbole.

### 3. Stellen Sie dem Graphen eine echte Frage```sh
kin locate "where are webhook retries handled"
kin refs ExactEntityName
kin trace ExactEntityName
kin overview

Was es von der Ausrichtung eines anderen Agents auf den MCP-Server unterscheidet, ist, dass die
Regel innerhalb des Agents durchgesetzt wird und nicht aus der Berechtigungsebene eines Anbieters
ausgeliehen wird. Es verfügt über Kins Tools plus genau zwei lokale, `edit_file` und
`write_file`. Es gibt keine Shell, kein grep und kein Dateilesetool, sodass es keine
Repository-Frage aus einer rohen Dateisuche beantworten kann, und ein Tool, das es erfindet, wird
beim Namen abgelehnt. Wenn Kin meldet, dass ein leeres Ergebnis nicht vertrauenswürdig ist, wird dem
Agenten mitgeteilt, dass die Antwort unbekannt ist, und er erhält die benannte Lücke, anstatt zu schlussfolgern,
dass die Sache nicht existiert. Jede Bearbeitung läuft innerhalb einer Kin-Transaktion unter einer Kin-
Sitzung, sodass die Änderung eine Herkunft trägt, die den Agenten benennt. Führen Sie zuerst `kin agent doctor
--base-url <url>` aus, um zu prüfen, dass beide Hälften antworten. Siehe
[die CLI-Referenz](https://github.com/firelock-ai/kin/blob/main/docs/cli-reference.md#kin-agent) für die vollständige Oberfläche.

Die Arbeit mit Claude Code, Codex, Cursor, Gemini und allem anderen, das MCP spricht,
bleibt erstklassig. `kin setup --intent agent` konfiguriert jeden Client, den es erkennt, in einem
Durchgang. Dies sind die Einzeiler pro Client, wenn Sie Kin lieber direkt
installieren möchten.

Führen Sie `kin init .` im Repository aus, bevor Sie einen Client verdrahten, nicht danach. Diese
Tools antworten aus dem Graphen, sodass ein Client, der auf ein Verzeichnis ohne Graphen zeigt,
eine Tool-Oberfläche ohne dahinterliegenden Inhalt erhält. `kin setup` sagt dies selbst: seine
Round-Trip-Prüfung meldet „kein initialisiertes Kin-Repository bei oder über“ dem
Verzeichnis, in dem es ausgeführt wurde, und weist Sie an, dort `kin init` auszuführen und das Setup erneut auszuführen.

Claude Code, aus einer Sitzung heraus:```
/plugin marketplace add firelock-ai/kin
/plugin install kin@kin

Gemini CLI:```sh
gemini extensions install https://github.com/firelock-ai/kin

Kiro akzeptiert dasselbe als Weblink:
[Add Kin to Kiro](https://kiro.dev/launch/mcp/add?name=kin&config=%7B%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22%40kinlab%2Fkin%22%2C%22mcp%22%2C%22start%22%5D%7D).

Cline akzeptiert den untenstehenden Standardeintrag statt eines Einzeilers. Seine CLI liest
`~/.cline/mcp.json`. In der VS-Code-Erweiterung öffnen Sie das MCP-Servers-Panel, dann
den Reiter Configure, dann Configure MCP Servers, und fügen den Eintrag dort hinzu.

Jeder andere Client, der eine Standard-MCP-Konfiguration liest, akzeptiert diesen Eintrag:```json
{
  "mcpServers": {
    "kin": { "command": "npx", "args": ["-y", "@kinlab/kin", "mcp", "start"] }
  }
}

Das Ergebnis ist `PASS`, `NEEDS ATTENTION` oder `WOULD BLOCK`, und es wird mit den
aus dem Graphen abgeleiteten Auswirkungen (Impact Kin), dem Kontext, der zur Behebung benötigt wird, und den
Belegen für beides geliefert. Die Autorenschaft wird deklariert, nicht verifiziert. Der Befehl blockiert
weder Ihren Merge noch ändert er den Graphenzustand. Er übergibt Belege an einen Menschen oder eine CI-
Richtlinie und endet dort.

## Wie Kin mit Git zusammenhängt

Neben Git heute. Repository-Autorität im Laufe der Zeit. Während der Brownfield-Einführung
bleibt Git eine explizite Import/Export-Interoperabilitätsgrenze; es beantwortet
niemals Kin-Laufzeitabfragen oder repariert fehlende Graphenwahrheit.

- `kin init` importiert die vollständige erreichbare Git-Historie und exakte Parent-Kanten.
  Kin hat bewusst keinen Modus für Teilhistorie oder reine Snapshot-Initialisierung.
- Nach dem Import besitzt Kins Graph die Repository-Identität, den Baumzustand, die Historie, die Refs
  und die semantischen Beziehungen. Dateisystem- und Git-Ansichten sind Projektionen.
- `kin git export --output ../repo.git` schreibt eine neue Bare-Git-Projektion aus
  einer graphbesitzenden Autoritätsgeneration. Es konsultiert weder Arbeitsdateien noch einen
  umgebenden `.git/`-Objektspeicher und lehnt ein bestehendes oder im Repository befindliches
  Ziel ab. Objekte, Refs und Verzeichnisse werden geleert, bevor die
  Veröffentlichung am Ziel ohne Ersetzung bestätigt wird. Die fähigkeitsverankerte
  Veröffentlichung ist derzeit auf Unix-Hosts verfügbar; andere Hosts lehnen ab, bevor
  der Export erstellt wird.

Dies ermöglicht einem Team, ein bestehendes Repository zu migrieren, ohne seinen Editor,
Compiler, sein Build-System oder die Git-Interoperabilität aufzugeben, während Kin autoritativ wird.

## Plattform und Reifegrad

Der Kern-Laufzeit und die Dateisystem-Projektion haben unterschiedliche
Support-Grenzen:

| Plattform | Core-Kin-Laufzeit | `kin-vfs`-Projektion |
| --- | --- | --- |
| macOS, Apple Silicon und Intel | Native Graph-, Vektor-, Daemon-, Setup-, MCP- und Review-Oberflächen sind im Release-Archiv enthalten. | Wird auf beiden Architekturen ausgeliefert und getestet. Es verwendet `DYLD_INSERT_LIBRARIES`; SIP-geschützte oder gehärtete Programme können die Injektion ablehnen. |
| Linux x86_64 und arm64 | `kin` und `kin-daemon` sind statische musl-Builds, die für glibc- und musl-Distributionen gedacht sind. | Das öffentliche VFS-Executable und der Shim sind GNU/glibc-Builds, keine musl-Builds. Sie sind gegen eine festgelegte glibc-Untergrenze von 2.31 gebaut und verlinken OpenSSL 3, daher benötigt ein Projektionshost beides; Debian 12 lädt sie, und Alpine und andere musl-Distributionen werden nicht als Projektionshosts unterstützt. Das Release weigert sich, ein Linux-Archiv zu veröffentlichen, dessen Binärdateien mehr glibc verlangen als diese Untergrenze. Der arm64-Release-Beweis läuft auf Ubuntu 24.04. |
| Natives Windows x86_64 | Frühe Unterstützung: Repositories werden aufgenommen und Graph- und lexikalische Abfragen antworten nativ, aber MCP- und Review-Workflows sind noch nicht Ende-zu-Ende durch den Installationsbeweis abgedeckt. WSL2 bleibt der empfohlene Pfad für vollständiges Kin. | Nicht ausgeliefert. Verwenden Sie WSL2 mit einer Linux-Distribution, die die glibc-Grenze für die Projektion erfüllt. |

Der Graph ist in jedem der obigen Fälle die Autorität. Der Shim, ein NFS-Mount, ein FUSE-
Mount und Windows ProjFS sind vier Möglichkeiten, diese Wahrheit als Dateien zu sehen, und Kin
wählt zwischen ihnen, indem es prüft, was dieser Host ausführen kann: einen Mount, wo einer
verfügbar ist, weil der Kernel ihn bedient und kein Prozess ihn entfernen kann,
mit dem injizierten Shim als Kompatibilitäts-Fallback auf macOS und Linux und
ProjFS führend auf Windows, wo kein Shim existiert. `kin vfs on` aktiviert den gewählten,
`kin vfs off` deaktiviert ihn, und `kin doctor` führt eine Zeile, die angibt, welcher
in Kraft ist und ob er funktioniert. Wo ein Modus fehlt, druckt Kin die
genaue Zeile, die ihn für Ihre Plattform installiert oder aktiviert.
[docs/projection.md](https://github.com/firelock-ai/kin/blob/main/docs/projection.md) enthält die vollständige Tabelle pro Plattform.

Die erste Indizierung liest die gesamte erreichbare Git-Historie, daher dauert `kin init` auf einem
großen oder langlebigen Repository Minuten, nicht Sekunden, bevor das Einbetten
beginnt. Nachdem `init` zurückkehrt, bereitet der Daemon weiterhin im
Hintergrund vor, und die ersten Agentenaufrufe auf einem großen Repository können
merklich länger dauern, um zu antworten.

Begrenzte arm64-Tests fanden den Kern-Graph- und lexikalischen Pfad bei 512 MB nutzbar,
aber das vollständige Einbetten lädt ein etwa 522 MB großes Modell herunter und benötigt derzeit 2 GB als
sichere Betriebsuntergrenze; 1 GB ist eine unsichere Kante und 512 MB können während des Einbettens
abbrechen. Dies sind beobachtete Alpha-Einschränkungen, keine universellen Größenversprechen.

Ein erfolgreiches `kin --version` stellt nur fest, dass die Kern-Binärdatei läuft. Es
stellt keine VFS-Kompatibilität oder eine live graphgestützte Projektion fest. Auf einem
unterstützten Unix-Host verwenden Sie `kin vfs status`, das jeden Projektionsmodus prüft und
ausgibt, was tatsächlich in Kraft ist, dann `kin setup status` und einen echten
`kin-vfs exec --workspace . -- <command>`-Start. Der VFS-Launcher enthält eine
Interpositions-Canary und meldet, wenn das Betriebssystem den Shim entfernt.
Die [kin-vfs-README](https://github.com/firelock-ai/kin-vfs#current-platform-and-package-boundaries)
enthält die vollständige Grenze.

Release-Artefakte werden mit Prüfsummen veröffentlicht und der Release-Workflow führt anonyme
Installation, Daemon/MCP, Einbettung und echte graphgestützte VFS-Projektionsprüfungen
über seine unterstützte Runner-Matrix aus. Der Workflow selbst ist öffentlich:
[Install Proof](https://github.com/firelock-ai/kin/actions/workflows/install-proof.yml).
Ein grünes Release stellt diese genauen Artefakte und Umgebungen fest; es ist keine
Behauptung, dass jede Distribution, jedes Tool oder jede Repository-Form bereits abgedeckt ist.

## FAQ

### Ersetzt Kin Git?

Neben Git heute. Repository-Autorität im Laufe der Zeit. Git bleibt eine explizite
Import/Export-Interoperabilitätsgrenze während der Brownfield-Einführung, sodass ein Team
ein bestehendes Repository migrieren kann, ohne seinen Editor, Compiler,
sein Build-System oder seine Git-Interoperabilität aufzugeben.

### Verlässt mein Code meinen Rechner?

Kin hält lokale Repository-Arbeit in Ihrer Umgebung, sodass Repository-Aufnahme,
Graphspeicherung und lokale Abfragen alle dort ausgeführt werden. KinLab ist ein separates
Produkt, das gehostete Zusammenarbeit unter expliziten Zugriffs- und Early-Access-
Vereinbarungen hinzufügt.

### Mit welchen Agenten funktioniert es?

Die Arbeit mit Claude Code, Codex, Cursor, Gemini und allem anderen, das MCP spricht,
bleibt erstklassig. `kin setup --intent agent` konfiguriert jeden Client, den es erkennt, in einem
Durchgang.

### Blockiert es einen Merge?

Review ist beratend, daher kennzeichnet es Risiken ohne zu blockieren, und die Merge-Entscheidung
bleibt bei Ihrem Team. `kin review shadow` übergibt Belege an einen Menschen oder eine CI-
Richtlinie und endet dort.

## Beweis-Haltung

Das veröffentlichte vorregistrierte Multi-SWE-Bench-Go-Beweispaket ist an einen
älteren Build gebunden, nicht an das sich bewegende neueste Release, und stellt keinen breiten
Geschwindigkeits-, Token-Einsparungs- oder Kategorie-Sieg-Anspruch auf. Vergleichende Ergebnisse werden hier
bis zur unabhängigen Verifizierung zurückgehalten.

Lesen Sie die Methodik, den Aufgabensatz, die Build-Identität und die Artefakte im
[öffentlichen Beweispaket](https://firelock.ai/labs/kin-proof). Behandeln Sie Behauptungen außerhalb
dieses gemessenen Umfangs als Hypothesen, bis sie ihren eigenen reproduzierbaren Beweis haben.

## Schreiben

Technische Notizen aus dem Bau von Kin, niedergeschrieben, damit ein Fremder sie wiederverwenden kann,
befinden sich auf [kinlab.ai/blog](https://kinlab.ai/blog) mit einem Feed auf
[kinlab.ai/rss.xml](https://kinlab.ai/rss.xml).

- [Der Check, der bestand, weil er nichts maß](https://kinlab.ai/blog/checks-that-cannot-fail)
- [Ihre Codesuche sagt, nichts verwendet es. Können Sie es löschen?](https://kinlab.ai/blog/empty-answer-safe-to-delete)

## Lernen und beitragen

- [Schnellstart und erweiterte Konfiguration](https://github.com/firelock-ai/kin/blob/main/docs/quickstart.md)
- [Speichergröße und was sie antreibt](https://github.com/firelock-ai/kin/blob/main/docs/store-size.md)
- [MCP-Tool-Referenz](https://github.com/firelock-ai/kin/blob/main/docs/mcp-tools.md)
- [Sprachunterstützung und was jede Stufe extrahiert](https://github.com/firelock-ai/kin/blob/main/docs/language-support.md)
- [Umgebungsvariablen-Referenz](https://github.com/firelock-ai/kin/blob/main/docs/env-vars.md)
- [Graph-first-These](https://github.com/firelock-ai/kin/blob/main/docs/thesis.md)
- [Schreib-Autoritätsmodell und sein Übergangszustand](https://github.com/firelock-ai/kin/blob/main/docs/write-authority-model.md)
- [GitHub Discussions](https://github.com/firelock-ai/kin/discussions)
- [Fehlerberichte und Feature-Anfragen](https://github.com/firelock-ai/kin/issues/new/choose)
- [Beitragsleitfaden](https://github.com/firelock-ai/kin/blob/main/CONTRIBUTING.md)
- [Private Sicherheitsmeldung](https://github.com/firelock-ai/kin/blob/main/SECURITY.md)

## Lizenz

[Apache-2.0](https://github.com/firelock-ai/kin/blob/main/LICENSE).

<p align="center"><em>Software, die sich an sich selbst erinnert.</em></p>