README.md

---
license: llama3.1
language:
- en
metrics:
- accuracy
base_model:
- NousResearch/Hermes-3-Llama-3.1-8B
pipeline_tag: text-generation
tags:
- lora
- qlora
- finetuned
- prycat
- blackwell
---
# Model Card for Model ID

prycat
prycat is a QLoRA fine-tuned version of NousResearch/Hermes-3-Llama-3.1-8B, 
trained using the BlackLoRA-N closed-loop self-improvement system developed 
by Prycat Research. It is a research artifact demonstrating empirical, measurable 
improvement in a local language model through automated regret-targeted fine-tuning
— with no cloud infrastructure, no API fees, and no data leaving the machine.


The model was trained on a single consumer GPU (RTX 3060, $300) in under an hour. 
Over 80 conversations, its average distance to a defined performance target dropped 
by 93%. The final 7 consecutive scored exchanges hit perfect scores across all five 
evaluation dimensions simultaneously.

## Model Details
Model Description
prycat is the first trained output of the BlackLoRA-N pipeline — a closed-loop QLoRA
fine-tuning system that watches its own conversations, identifies where it is underperforming,
synthesizes corrective training data, and updates its own weights. The system is grounded
in David Blackwell's Approachability Theorem (1956), which guarantees that for any decision
process operating below a target performance region, there exists a minimal-regret path back
to that region.

Applied to transformer fine-tuning: you define what "good" looks like across five dimensions,
measure where the model currently sits, and run gradient updates targeted at closing that gap.
This is not prompt engineering or RLHF — it is regret-geometry applied to weight updates on a
consumer GPU.
Uses
Direct Use
prycat is intended to be run locally via Ollama as a research assistant. It is optimized for:

Direct, concise answers without filler
Honest uncertainty flagging — saying "I don't know" cleanly rather than hedging with prose
Genuine follow-up questions when a topic warrants them
Accurate reasoning with no hallucination cover
Clear refusal of harmful content
Install and run:

ollama pull hf.co/prycat-research/prycat
ollama run prycat
Downstream Use
prycat can serve as a drop-in replacement for Hermes-3-8B in any Ollama-based workflow. It is particularly suited for research assistance, technical reasoning, and iterative Q&A sessions where honesty and directness matter more than confident-sounding prose.

The BlackLoRA-N training pipeline is open source. Researchers can fork the system, define their own five-dimensional performance target, and run their own convergence experiment against any base model.

Out-of-Scope Use
Production systems — this is a research artifact from a 76-exchange observation window, not a production-hardened model
Medical, legal, or financial advice — the model has not been evaluated for these domains
High-stakes autonomous decisions — no model at this scale should be used without human oversight
Non-English use — evaluated exclusively in English
Bias, Risks, and Limitations
prycat inherits all biases present in Meta Llama 3.1 and NousResearch Hermes-3. Additional limitations specific to this training run:

Short observation window. 76 scored exchanges is a proof of concept. Thousands of conversations would make the statistical case significantly stronger.
Judge-model shared architecture. Both the oracle (which generates training data) and the evaluator (which scores responses) are based on Hermes-3-8B. A systematic blind spot in one can appear in the other. An independent external evaluator would strengthen future runs.
Curiosity dimension calibration. 57% of all exchanges missed the curiosity target — but post-hoc analysis confirmed this was largely an evaluator calibration gap, not a model failure. The evaluator was flagging short settled exchanges as curiosity failures when asking a follow-up question would have been inappropriate.
No held-out benchmark yet. The trained model has not been evaluated against questions it has never seen. That is the next experiment.
Recommendations
Run prycat against a held-out benchmark before using it for any purpose beyond research exploration. Compare against the base Hermes-3-8B on your specific use case. The convergence results are real but the observation window is short.

How to Get Started
# Via Ollama (recommended)
ollama pull hf.co/prycat-research/prycat
ollama run prycat

# Or pull directly
ollama run hf.co/prycat-research/prycat
The model runs comfortably on 8GB VRAM at Q4_K_M quantization.

Training Details
Training Data
341 training pairs generated by the BlackLoRA-N Oracle from 80 real conversations over a 32.5-hour observation window (April 14–16, 2026). The Oracle analyzes the model's regret vector — the gap between current performance and the target set S — and synthesizes fictional conversations that demonstrate correct behavior specifically along the highest-regret dimensions.

Additionally, 25 immutable axiom pairs (human-written ground-truth question/answer pairs confirmed by the operator) are injected into every training batch regardless of what the oracle generates. These anchor the model to verified factual and logical ground truth that cannot drift.

No public dataset was used. Training data is available in the repository at blackwell/training_pairs.jsonl.

Training Procedure
The BlackLoRA-N pipeline:

Score — every conversation is evaluated across 5 dimensions (accuracy, logic, tone, curiosity, safety) by a deterministic judge (temperature 0.0)
Measure regret — compute Euclidean distance from current payoff vector to the convex target set S
Synthesize — oracle (temperature 0.80, creative persona) generates corrective training pairs targeting highest-regret dimensions
Gate — drift monitor checks oracle/evaluator gap; probe gate verifies 25 axiom pairs pass before touching weights
Train — QLoRA gradient update (rank 32, 200 steps, bfloat16)
Register — merged model exported to GGUF and registered in Ollama
Training Hyperparameters
Parameter	Value
LoRA rank	32
LoRA alpha	64
Training steps	200
Optimizer	AdamW 8-bit
Precision	bfloat16
Final training loss	0.2589
Trainable parameters	83M / 8B (1.03%)
Max sequence length	2048
Speeds, Sizes, Times
Training time: 45 minutes 52 seconds
Hardware: NVIDIA RTX 3060 12GB (consumer GPU)
Training pairs: 341
Gradient steps: 200
Evaluation
Testing Data and Metrics
Evaluation was performed in-loop across 76 scored exchanges from 84 total sessions over 32.5 hours.

The Blackwell Convergence Metric — rolling mean Euclidean distance to the convex target set S — is the primary metric. S is defined as the Cartesian product of acceptable ranges across five dimensions:

Dimension	Target range	Baseline (plateau)	Post-training
Accuracy	90–100%	failing 55% of exchanges	resolved
Logic	80–100%	failing 53% of exchanges	resolved
Tone	60–100%	never failed	—
Curiosity	70–100%	failing 57% of exchanges	resolved (evaluator calibration)
Safety	90–100%	failing 7% of exchanges	resolved
Results
Window	Rolling avg distance to S
Exchanges 1–10	0.62
Exchanges 6–15	0.88 (peak — worst point)
Exchanges 21–40	0.81 (plateau)
Exchanges 46–55	0.14
Exchanges 51–60	0.03
Exchanges 61–76	0.00
93% reduction in average distance to target set S
84% of Phase III exchanges landed inside S
100% of the final 7 consecutive exchanges hit d(S) = 0
$0 in cloud compute costs
Summary
Starting from a plateau where zero exchanges met all five targets simultaneously, BlackLoRA-N drove the rolling average distance to zero in under 80 conversations on a $300 consumer GPU. The convergence is monotonic after the training run completes and holds through the end of the observation window.

Environmental Impact
Hardware: NVIDIA RTX 3060 12GB — consumer desktop GPU
Hours used: 0.76 hours (45 minutes 52 seconds)
Cloud Provider: None — fully local, air-gapped
Compute Region: N/A
Carbon emitted: Negligible — single consumer GPU, sub-1-hour training run, no data center
Technical Specifications
Model Architecture
8-billion parameter causal language model (Llama 3.1 architecture). QLoRA adapter at rank 32 targeting all attention projection layers. Merged to full weights for GGUF export. Q4_K_M quantization for Ollama distribution.

The training objective is not next-token prediction on a static dataset — it is regret minimization toward a convex target set in 5-dimensional payoff space, implemented as a closed-loop QLoRA feedback mechanism. The mathematical foundation is Blackwell's Approachability Theorem (1956).

Compute Infrastructure
Component	Spec
GPU	NVIDIA RTX 3060 12GB
Training framework	unsloth + HuggingFace PEFT
Serving	Ollama (GGUF Q4_K_M)
OS	Windows 11
Citation
BibTeX:

@misc{prycat2026,
  author       = {Prycat Research},
  title        = {prycat: Blackwell Convergence via Closed-Loop QLoRA Fine-Tuning},
  year         = {2026},
  publisher    = {HuggingFace},
  howpublished = {\url{https://huggingface.co/prycat-research/prycat}},
  note         = {BlackLoRA-N v1.0 — 93\% regret reduction over 80 conversations on RTX 3060}
}
APA:
Prycat Research. (2026). prycat: Blackwell Convergence via Closed-Loop QLoRA Fine-Tuning (Version 1.0.0) [Large language model]. HuggingFace. https://huggingface.co/prycat-research/prycat

Extended Description
What This Model Actually Is
Most fine-tuned models are static artifacts. You train them once on a fixed dataset and they are frozen forever. prycat is different — not because of what it is, but because of how it was made and what the system that made it can keep doing.

The BlackLoRA-N pipeline treats model improvement as a geometry problem. You define a target region in five-dimensional space — one axis for accuracy, one for logic, one for tone, one for curiosity, one for safety. You measure where the model currently sits. The gap between where it is and the nearest point inside the target region is called the regret distance. The entire system exists to drive that number toward zero and keep it there.

David Blackwell proved in 1956 that for any repeated decision process operating below a target performance region, there exists a strategy that guarantees convergence. The BlackLoRA-N system is that strategy, running on a transformer, implemented in Python, on a GPU that costs $300.

Over 80 conversations and one 46-minute training run, the rolling average regret distance dropped from 0.88 to 0.00. The model that answered the 76th question was measurably, verifiably different from the one that answered the 6th.

What Made It Work
Three design decisions matter:

Oracle-evaluator decorrelation. The system that generates training data (the oracle) runs at temperature 0.80 — creative, exploratory, pushing edge cases. The system that scores responses (the judge) runs at temperature 0.00 — fully deterministic, conservative, correctness-biased. Both are Hermes-3-8B under the hood, but by biasing them toward opposite ends of the creativity/determinism spectrum, their failure modes are decorrelated. A blind spot in one is unlikely to be a blind spot in the other.

Immutable axiom injection. 25 human-written question/answer pairs — confirmed by the operator — are injected into every gradient update regardless of what the oracle generates. The model cannot train itself away from verified ground truth. This prevents the most dangerous failure mode: the system optimizing a metric rather than the actual behavior.

Drift monitoring. Before every training run, the system checks whether the gap between oracle and evaluator scores exceeds a threshold. If the scorekeeper has drifted, training is aborted. You can't improve toward a target that's moving.

The Numbers
341 training pairs. 83 million trainable parameters out of 8 billion — 1.03% of the model, precisely targeted. 200 gradient steps. 46 minutes. One RTX 3060. $0 in cloud costs. 93% reduction in average distance to target. 100% in-target rate across the final 7 consecutive exchanges.

One person. A desktop. A theorem from 1956.