KIN — Verification Translator (3B Canonical)
KIN translates machine-generated security claims into leveled briefs with replayable evidence checks. Not a chatbot. Not an encyclopedia. A bridge between agent output and human decisions.
No check, no confidence. If the claim has no replayable verification, KIN refuses to sound sure. That refusal is the product.
The Problem
Maintainers are drowning in AI-shaped reports that look expert and are not. Copilot files critical PRs. Huntr contestants submit AI-generated writeups. Agent traces produce 40-file refactors with no comment a person can hold in working memory.
The scarce skill is no longer "can a human write the exploit narrative." The scarce thing is can a human know what the machine just claimed, and whether to trust it.
The Five-Field Brief
Every KIN translation bottoms out in five fields:
- Claim — one sentence: what is alleged
- Blast radius — what breaks if true: data, money, identity, model weights
- Why the model thinks so — the short generator: CWE, invariant, missing check
- How to see it yourself — PoC, failing test, command, screenshot of the trace
- Confidence and what would falsify it — what evidence would disprove the claim
Rendered at three altitudes: TL;DR (maintainer), Mechanic (mid engineer), First p rinciples (beginner). Same object, different compression ratio.
Canonical Status
This is the canonical KIN model (3B, merged weights). GGUF version at kin-cybersecurity-3b-gguf. Training data at kin-cyber-dpo-v2. Live demo at kin-cybersec Space.
Quick Start
from transformers import pipeline
messages = [
{"role": "system", "content": "You are KIN — a verification translator. Translate the security claim into a five-field brief: claim, blast radius, why the model thinks so, how to see it yourself, confidence and what would falsify it. If field 4 is missing, refuse to sound sure. Render at TL;DR, mechanic, and first-principles levels."},
{"role": "user", "content": "<paste PR diff, review comment, or agent trace here>"}
]
pipe = pipeline("text-generation", model="nyxspecter4/kin-cybersecurity-3b", device="cuda")
output = pipe(messages, max_new_tokens=512, return_full_text=False)
print(output[0]["generated_text"])
Ollama (one command)
ollama pull nyxspecter4/kin-cybersecurity-3b-gguf:Q4_K_M
ollama run nyxspecter4/kin-cybersecurity-3b-gguf:Q4_K_M
Critical: System Prompt
KIN was trained with a specific verification translator persona. Using a different prompt will degrade quality significantly.
You are KIN — a verification translator. Translate the security claim into a five-field brief: claim, blast radius, why the model thinks so, how to see it yourself, confidence and what would falsify it. If field 4 is missing, refuse to sound sure. Render at TL;DR, mechanic, and first-principles levels.
Training Details (v1 — current shipped weights)
| Parameter | Value |
|---|---|
| Base model | Qwen2.5-3B-Instruct |
| Method | LoRA SFT + DPO |
| LoRA rank | 8 |
| LoRA alpha | 16 |
| Target modules | q_proj, k_proj, v_proj, o_proj |
| Training data | 1,635 DPO pairs (verified audit vs vague filing) |
| Framework | TRL 0.14.0, Transformers 4.48.0 |
| Merged weights | Yes (6.2GB safetensors) |
| Temperature | 0.3 recommended |
v2 Retrain (PENDING —
verification translator expansion)
| Parameter | KIN v1 (current) | KIN v2 (target) |
|---|---|---|
| LoRA rank | 8 | 16 |
| LoRA alpha | 16 | 32 |
| Target modules | 4 (attention) | 7 (all-linear) |
| Training data | 1,635 pairs | ~2,135 pairs (+500 PR review translation) |
| Pair shape | audit vs vague | brief+check vs jargon |
The DPO Contrast
The training data encodes a single preference: chosen = structured audit with root cause, fix, and regression test. Rejected = vague filing with guesses and no verification. The v2 expansion adds PR review and bounty report translation pairs with the same contrast.
Usage Examples
CTF Challenge Coaching
# Input: challenge description
# "We are given a binary that reads user input and prints the flag if the input matches a secret. The binary uses strcmp for comparison."
# KIN Output (TL;DR): Classic strcmp timing side-channel. Use time-based comparison to leak the flag byte by byte.
# Mechanic: strcmp returns early on first mismatch. Measure response time per byte position to determine correct prefix.
# First principles: strcmp compares char-by-char left to right, returning at first difference. More correct chars = more comparisons = more time. This is CWE-208 (Observable Timing Discrepancy).
Bug Bounty Brief
# Input: vulnerable code snippet
# "def load_model(path): return pickle.load(open(path, 'rb'))"
# KIN Output:
# CLAIM: Arbitrary code execution via pickle deserialization.
# BLAST RADIUS: Full system compromise — pickle.loads executes arbitrary Python via __reduce__.
# WHY: CWE-502, no input validation on untrusted serialized data.
# VERIFY: Craft a pickle payload with __reduce__ returning (os.system, ("id",)). Load it.
# CONFIDENCE: High — falsified only if path is guaranteed safe or weights_only=True is enforced.
Limitations
- v1 was trained on monk-plugin bug bounty scenarios, not general PR reviews
- The five-field brief structure is emergent from training, not enforced by architecture
- Field 4 (replayable check) quality depends on the input containing enough signal
- The hash seal (diff + brief + test command) is planned for v2, not yet implemented
License
Apache 2.0