Peripheral

A small, local model that manages a knowledge base, so a frontier model doesn't have to.

Model · KMA-Bench · Write-up

Peripheral is a fine-tuned 8B model that does the unglamorous admin around a filesystem knowledge base: it routes a query to the right files, notices when stored knowledge has gone stale, and decides whether a recent change is safe to serve. It runs locally, costs nothing per call, and on these knowledge-management tasks it beats a frontier API at a fraction of the latency and cost.

It's a knowledge management agent (KMA): a specialist, not a better frontier model. On KMA-Bench it scores 81% to Claude Sonnet 4.6's 76%, at ~760ms per call (roughly 5x faster and 5x cheaper).

Note

Peripheral was trained on ~7,000 task examples and beats a zero-shot generalist, but it transfers only partially to unseen domains. See the model card for the honest limitations.

Features

• Local and cheap: an 8B Q4_K_M GGUF (~4.8 GB VRAM) you run in LM Studio, at zero API cost.
• Three jobs, one model: routing, change evaluation, and serve/annotate/block gating, each a tagged prompt that returns a single JSON object.
• Cheap heuristics do the easy work: a topic-keyword index for routing and git diffs for staleness; the model is reserved for the hard call: is this change legitimate, corrupt, or somewhere in between?
• Reproducible: generate the training data and fine-tune on your own knowledge base, no frontier API required.

How it works

A query passes through a pipeline of cheap heuristics before the model is asked anything, so the model only does the work that genuinely needs judgement.

User query
    │
    ▼
┌──────────────────────────────────────────────────────────┐
│                     Peripheral pipeline                  │
│  ┌────────┐    ┌────────┐    ┌──────────────────┐        │
│  │ Router │──▶│  PVL   │──▶│   Block Gate     │         │
│  │ topic  │    │ git    │    │ serve / annotate │        │
│  │ index  │    │ diff   │    │ / block          │        │
│  └────────┘    └────────┘    └────────┬─────────┘        │
│      │                                │                  │
│  relevant files                ┌──────┴──────┐           │
│  (5-6x fewer tokens)           │ Eval (diff  │           │
│                                │ classifier) │           │
│                                └─────────────┘           │
└──────────────────────────────────────────────────────────┘
    │
    ▼
Response from verified, routed context

• Router: maps a query to the relevant wiki files via a hand-built topic-keyword index (100% hit rate vs ~30% for embedding search on a non-English KB).
• PVL (Peripheral Vision Layer): an append-only change log from git diffs that flags recently modified files, at ~226 tokens per query.
• Block Gate: instead of injecting a "this might be stale" warning (which the model ignores), it withholds the content and serves the diff plus the previous version, reframing the task as evaluate this change.
• Peripheral (the model): Qwen3-8B fine-tuned with QLoRA, the judgement layer that classifies a change as accept / partial / reject.

See docs/architecture.md for the full design.

Results

On KMA-Bench, averaged over multiple runs across three knowledge bases (% correct):

Model	Diff Eval	Routing	Gate	Overall	Latency
Heuristic	44%	75%	100%	64%	0 ms
Base Qwen3-8B	46%	13%	16%	30%	~3,500 ms
Peripheral (8B)	71%	88%	96%	81%	~760 ms
Claude Sonnet 4.6 (zero-shot)	60%	96%	83%	76%	~4,100 ms

Fine-tuning carried the base model from 30% (it couldn't reliably emit valid JSON) to 81%. The public benchmark ships 166 cases (French + PostHog); ClickHouse was evaluated too but isn't redistributed.

Getting Started

Prerequisites: Python 3.11+, uv, and LM Studio (for the local model) or an Anthropic API key.

uv sync
cp .env.example .env        # add your Anthropic key only if benchmarking Claude

Run the benchmark against the local model (loaded in LM Studio) or Claude:

uv run python scripts/benchmark/benchmark_core.py --backend lmstudio --model-name peripheral-8b
uv run python scripts/benchmark/benchmark_core.py --backend anthropic

Reproduce the training data and fine-tune split on your own knowledge base, generated locally, zero API cost:

uv run python scripts/datagen/gen_eval.py    --wiki-path ./french-kb/wiki --output ./training-data/eval
uv run python scripts/datagen/gen_routing.py --wiki-path ./french-kb/wiki --output ./training-data/routing
uv run python scripts/datagen/gen_gate.py    --wiki-path ./french-kb/wiki --output ./training-data/gate
uv run python scripts/training/prep_finetune.py --data-dir ./training-data --output ./finetune-data

Fine-tune the prepared split with Unsloth (QLoRA on a single GPU) and export a Q4_K_M GGUF.

Using the model

The fastest path is LM Studio: search malgamves/peripheral-8b, download the GGUF, and give the model a task instruction ([EVAL], [ROUTE], or [GATE]) plus your input. It replies with a single JSON object.

Tip

Keep the temperature low (~0.1). Peripheral is trained to emit short, deterministic JSON. Full prompt formats are in the model card.

Project layout

peripheral/
├── french-kb/       French language-learning wiki (the author's notes)
├── scripts/
│   ├── benchmark/   KMA-Bench runners
│   ├── datagen/     Training-data generation
│   ├── measurement/ Token-measurement experiments
│   ├── pvl/         Peripheral Vision Layer + block gate
│   ├── training/    Fine-tuning prep (train/val split)
│   └── validation/  Index-validation experiments
└── docs/            Architecture notes + model card

The benchmark lives in its own repo: KMA-Bench.

Note

An MCP Server is coming!!

Documentation

• Architecture: the pipeline, the four tasks, and the data flow.
• Model card: prompts, results, training details, and limitations.
• Write-up: the full story behind the project.