Daecore/gliclass-std-base-v3-5facet-qint8-v2

GLiClass Base v3, five-facet memory classifier

Summary

This model tags passages of working notes and documentation with five independent facets: trap, decision, constraint, mechanism, and procedure. It is a supervised fine-tune of knowledgator/gliclass-base-v3.0 trained on 59,886 labeled passages and shipped as a 452.8 MB ONNX bundle qualified on CPU, CUDA, and DirectML.

On a frozen 1,300-row held-out panel drawn from three unseen document families, it reached macro average precision 0.9676 against 0.8526 for the previous classifier, a paired gain of 0.1150 with every facet improving. At 90% recall it is 0.902 precise on average against 0.719 before. The gain concentrates on the two hard facets: decision rose from 0.678 to 0.914 average precision and procedure from 0.817 to 0.958.

Two caveats travel with every number below. All labels, for training and for evaluation, are frontier-model judgments under a frozen protocol, not human annotations. All evaluation panels are generated documents, chosen because they span far more domains and document shapes than the operator's own corpus; how the model behaves on unrelated real documents has not been measured.

Model details

Item	Value
Architecture	GLiClass single-pass label-conditioned classifier on a DeBERTa-v3 base backbone
Parameters	186.5M
Input contract	768 tokens per passage, five label prompts
Output	five independent posteriors in [0, 1], temperature-scaled per facet
Serialized artifact	model.onnx, 452,812,018 bytes, opset 17
Quantization	signed INT8 on the token-embedding matrix only; the transformer body stays FP32
Threshold tables	two frozen operating views, contract and recall_leaning
Deployment state	promotion-qualified; activation as the shipped default is a separate step

The artifact size follows from the quantization choice: the 128k-entry embedding table, about 98M parameters, is stored at one byte per weight while the 88M-parameter body stays at four. Full-graph INT8 was not qualified.

Intended use

The model stamps passages inside a local-first memory system so that retrieval can weight evidence by kind. The full posterior map is the product; thresholds are advisory views for consumers that need a hard label. It is not a safety classifier, a factuality judge, or an authority detector, and it should not be used to filter what a retrieval system is allowed to return.

Task and labels

Each facet answers one question about a passage:

• trap: it names a specific mistake, hazard, pitfall, or failure mode.
• decision: it makes or records a choice among alternatives.
• constraint: it states a rule, policy, invariant, or restricting condition.
• mechanism: it explains how something works.
• procedure: it gives sequenced steps for carrying out a task.

Facets overlap freely. The hardest boundary is between a passage that makes a decision and one that merely discusses or mentions one. Labels distinguish "performs" from "mentions only", and mentions-only rows count as negatives for both training and evaluation.

Label provenance. Every label was produced by a language model applying the same one-sentence facet definitions the classifier sees. Training rows received one primary judgment from GPT-5.6 (Sol, medium reasoning), with a frozen 400-row cross-model audit by GPT-5.6 (Terra, high) and a Sol-high tiebreak only where the two disagreed semantically. Calibration and promotion panels used two independent Sol-high sessions per row plus a third Sol-xhigh session that saw only the disputed fields. Unresolved fields stay unresolved and are masked per facet; nothing unresolved becomes a negative.

Before adopting model judges, the operator labeled about fifty passages by hand and compared. The hand labels were not reliable enough to serve as an answer key: attention drifted toward one or two facets per passage, and rows came out either under- or over-labeled relative to the definitions. Frontier judgments applied the definitions more evenly, so they became the label instrument. The consequence is stated plainly in every result: scores measure agreement with that instrument, not with human ground truth.

Training data

Lane	Rows	Origin
Final training set	59,886	54,803 generated, 5,083 from the operator's own project documentation

Generated documents come from fictional organizations written as complete documents (procedures, incident reports, decision records, design notes) and then passed through the production parser. They were preferred over the operator's real corpus for both training and evaluation because they cover many more domains, document shapes, and organizational settings; the real corpus is one person's projects and too narrow to generalize from.

Splits are by whole source family, never by row. The seven families reserved for calibration and promotion were removed from training along with 3,875 predecessor training rows that shared them. Calibration and promotion families are disjoint from each other and from training by family, document lineage, exact passage identity, and lexical near-duplicate screening.

The final fit used weighted binary cross-entropy with a 2.0 multiplier on mentions-only hard negatives, learning rate 2e-5, batch 4 with 8 accumulation steps, four epochs, and an equal-weight average of the checkpoints from epochs 2 through 4. Generated and real rows were weighted equally.

Evaluation data

Panel	Rows	Families	Origin	Role
Calibration	1,700	4	generated	fit temperatures and threshold tables; no evaluation authority
Promotion	1,300	3	generated	one sealed read; the numbers reported below

Promotion-panel support per facet, with mentions-only rows counted as negatives. Prevalence equals the average precision a random ranker would score.

Facet	Positive	Mentions only	Negative	Unresolved	Prevalence
trap	933	62	305	0	0.718
decision	598	398	303	1	0.460
constraint	1,187	32	81	0	0.913
mechanism	892	62	343	3	0.688
procedure	485	277	531	7	0.375

The macro random floor is 0.631. Constraint is near saturation at 0.913 prevalence, so its average precision carries little information and the macro average leans on the other four facets. The panel was deliberately enriched for hard decision and procedure rows; it is not a natural-traffic sample.

Evaluation protocol

The promotion plan was frozen on 2026-08-12 before the candidate was scored: one read of the panel, bootstrap seed 20260812, 10,000 draws resampling whole source families, 95% one-sided bounds, and zero permitted stamp flips between the reference scorer and the production ONNX adapter. Pass criteria were pre-registered on the decision facet under its frozen contract threshold: precision at least 0.70 with a one-sided 95% lower bound at least 0.60, and recall at least 0.50. Threshold tables were fitted on the calibration panel and bound into the prediction receipt; nothing was tuned on the promotion panel.

Average precision and precision at fixed recall are the primary metrics because they do not depend on a threshold. Brier score and 10-bin expected calibration error report probability quality separately from ranking quality.

Results

Promotion panel, 1,300 rows, three families, single sealed read. "Previous" is the classifier this model replaces.

Facet	Prevalence	AP, this model	AP, previous	P@R90, this model	P@R90, previous	P@R95, this model	P@R95, previous
trap	0.718	0.9864	0.8931	0.960	0.832	0.935	0.784
decision	0.460	0.9135	0.6783	0.741	0.504	0.658	0.484
constraint	0.913	0.9986	0.9884	0.996	0.956	0.995	0.942
mechanism	0.688	0.9817	0.8865	0.926	0.777	0.891	0.736
procedure	0.375	0.9578	0.8167	0.886	0.528	0.822	0.489
macro	0.631	0.9676	0.8526	0.902	0.719	0.860	0.687

The macro gain is 0.1150. The same candidate gained 0.1200 on the separate calibration panel, so the two panels agree within 0.005. The one-sided 95% lower bound on the macro precision gain under the frozen contract thresholds is 0.009; the decision-facet precision gain has a negative lower bound, because the previous classifier's decision threshold was so strict that it predicted only 26 positives at 92% precision and 4% recall.

Frozen-threshold operating points on the promotion panel. The contract table is the stricter view; the pre-registered gates apply to decision.

Facet	Threshold	Precision	Recall	Predicted positive
trap	0.976	0.995	0.636	596
decision	0.485	0.890	0.703	473
constraint	0.993	1.000	0.802	952
mechanism	0.900	0.992	0.655	591
procedure	0.578	0.946	0.715	371

The recall denominators in this table do not all match the support table above. Where a facet has unresolved rows, the promoted model's recall is computed over a slightly larger set: decision 599 against 598 positives, mechanism 895 against 892, procedure 491 against 485. The previous classifier is scored over the support counts, except procedure at 487. The gaps track the per-facet unresolved rows, which the sealed read did not mask identically for the two models. The effect is conservative for the promoted model — a larger denominator lowers its recall — and no gate outcome changes.

Decision passed all three gates: precision 0.890 against a 0.70 floor, a one-sided 95% lower bound of 0.872 against 0.60, and recall 0.703 against 0.50. The operating point encodes a product judgment: surfacing a non-decision as a decision is treated as worse than missing one. The recall_leaning table (decision threshold 0.193) exists for consumers with the opposite preference.

Calibration. Per-facet temperatures fitted on the calibration panel were 1.89 (trap), 2.40 (decision), 1.69 (constraint), 1.50 (mechanism), and 2.05 (procedure). On the promotion panel the calibrated posteriors score macro Brier 0.072 and macro expected calibration error 0.039, against 0.349 and 0.374 for the previous classifier.

Held-family slices are diagnostic only: macro average precision was 0.962, 0.967, and 0.974 across the three families for this model and 0.851, 0.850, and 0.859 for the previous one.

Baselines and comparisons

Ordered by how directly each comparison can be checked.

Previous classifier. A ModernBERT-base sequence-classification head used as a zero-shot entailment judge: one pass per facet, five passes per passage. Its staged bundle declares ModernBertForSequenceClassification over the two labels entailment and not_entailment, 22 layers at hidden size 768, and a 599,027,211-byte FP32 model.onnx — about 1.3 times the promoted artifact for five times the work per passage. Its frozen thresholds were fitted on an older population and artifact, which is why its contract recall collapsed to 0.001 on trap and 0.040 on decision on this panel; the threshold-free columns above are the fair comparison.

Lexical baseline. A word-level TF-IDF (1-2 grams, 200k features) with one balanced logistic-regression head per facet, trained on the same 59,886 rows and scored on the same 1,300-row panel under the same label rules.

Facet	Floor	TF-IDF + LR	This model	Previous
trap	0.718	0.970	0.986	0.893
decision	0.460	0.847	0.914	0.678
constraint	0.913	0.997	0.999	0.988
mechanism	0.688	0.963	0.982	0.886
procedure	0.375	0.914	0.958	0.817
macro AP	0.631	0.938	0.968	0.853
macro P@R90		0.834	0.902	0.719
macro P@R95		0.786	0.860	0.687

The linear model lands 0.029 macro average precision below this model and well above the previous classifier. Much of the task is lexical on generated text. The fine-tune earns its size at high recall on the hard facets: at 95% recall it is 9 points more precise on decision and 17 points more precise on procedure than the linear model, and those are the operating regions the memory system runs in.

Zero-shot frontier models. A score-blind 300-row subsample of the promotion panel, 100 rows per family, scored under one shared prompt, output schema, and label set; each external model returned one confidence per facet. This sample is not independent of the promotion read, and each external configuration was run once, so run-to-run variance is not estimated. Subsample support: trap 213/87, decision 137/163, constraint 271/29, mechanism 194/105 with one unresolved, procedure 106/194 (positive/negative).

Model	Setup	Macro AP	Decision AP	Procedure AP	Macro P@R90
This model	supervised fine-tune	0.9671	0.9140	0.9500	0.8872
GPT-5.4	zero-shot, high reasoning	0.9242	0.7885	0.9177	0.8016
GPT-5.5	zero-shot, high reasoning	0.9162	0.7691	0.9210	0.8064
GPT-5.5	zero-shot, low reasoning	0.9082	0.7127	0.9209	0.7924
GPT-5.4	zero-shot, low reasoning	0.8734	0.6985	0.8337	0.6705
Previous classifier	prior local model	0.8368	0.5992	0.8387	0.7007
GPT-5.3-Codex-Spark	zero-shot, low reasoning	0.8086	0.5387	0.7684	0.7156
Nemotron 3 Ultra 550B-A55B	zero-shot, reasoning off	0.7356	0.5474	0.7163	0.6144
Gemma 4 26B-A4B IT	zero-shot, reasoning off	0.7103	0.4970	0.6707	0.6144

Paired macro average-precision differences from this model, with family-grouped 95% intervals: GPT-5.4 high −0.0428 [−0.0523, −0.0339]; GPT-5.5 high −0.0508 [−0.0548, −0.0366]; GPT-5.5 low −0.0588 [−0.0666, −0.0442]; GPT-5.4 low −0.0937 [−0.1015, −0.0827]. Every interval excludes parity. Raising reasoning effort improved GPT-5.4 by 0.0509 [0.0456, 0.0589] and GPT-5.5 by 0.0080 [0.0014, 0.0204]; it narrows the gap without closing it. Two unplanned repeats of the Spark run spanned 0.8086 to 0.8496, a spread of 0.041 that nearly matches the smallest GPT gap and exceeds every one of the four interval widths, which is the reason single runs are flagged above.

The open-weight rows are kept for completeness but carry a scoring caveat: their confidences were much coarser than the classifier's posteriors, and once tied zero scores had to be admitted at high recall their P@R90 fell to the sample's macro prevalence. Their deltas (−0.23 and −0.26) are partly an artifact of that coarseness.

This comparison shows task specialization, not general capability. The classifier was trained on roughly 60,000 examples of how the label instrument applies the definitions; the external models saw the definitions once. Where a frontier model and this classifier disagree on a row, the panel cannot say which is right.

How the recipe was chosen

Selection ran on generated development panels held out by whole document family; none of them carried promotion authority. Numbers are macro average precision unless stated.

1. Data first. On a 1,000-row eight-family development panel (858 fully resolved rows, random floor 0.654) with the larger GLiClass backbone, training on the predecessor's data alone scored 0.929 and adding more of the operator's real documents scored 0.929; adding twelve generated document families scored 0.968. Two loss-side branches on top of that baseline were rejected: a data curriculum tied it (+0.0005, interval spanning zero) with worse calibration, and a robust-loss variant lost (−0.0018, interval entirely below zero).
2. Targeted reserve. Appending the independently reviewed generated reserve added +0.0025 [+0.0009, +0.0039].
3. Context window. Widening the input from 416 to 768 tokens added +0.0048 [+0.0028, +0.0068] on development and +0.0033 [+0.0011, +0.0065] on a separate held-out set. A counterfactual-projector branch on minimal pairs changed nothing (+0.0001) and was dropped.
4. Backbone size. With the full data and a matched recipe on a 5,298-row eight-family panel, the larger backbone beat the base by 0.0042 average precision and 0.0152 at 90% recall [+0.0015, +0.0451], but cost 2.6 times the artifact bytes, 2.4 times the training time, and 1.7 times peak GPU memory, while the base scored 1.8 times as many rows per second. The base was selected as the product architecture.
5. Backbone variant and window. On the standard GLiClass Base v3 (DeBERTa-v3) backbone, 768 tokens scored 0.928 against 0.914 at 512, with procedure moving from 0.765 to 0.821. The backbone declares a 512-position limit; the 768-token contract is a measured improvement, retained because every trial confirmed it.
6. Final fit. The frozen recipe was trained once on all 59,886 rows, calibrated, compressed, and read once on the promotion panel.

What did not help, in one place: more real documents without generated diversity, the data curriculum, the robust loss, the counterfactual projector, and the larger backbone at its cost. Better and more diverse examples, boundary cases, and a wider context did the work.

Runtime

The shipped artifact is the INT8 bundle. Quantization was qualified as a compression step, not a retrain: the FP32 export and the INT8 export were scored on the same 5,298-row eight-family panel and compared directly.

Item	Value
FP32 export	747,319,179 bytes
INT8 export	452,812,018 bytes, 39.4% smaller
Quantization	signed INT8 weights, per-channel off, reduce-range off, one operator type; 24 constant-identity nodes folded
Toolchain	onnx 1.21.0, onnxruntime 1.24.4, opset 17
Macro average-precision change, INT8 minus FP32	+0.000119, family-grouped 95% interval [-0.000038, +0.000187]
Posterior absolute error, INT8 against FP32	mean 0.00088, p95 0.00483, maximum 0.0516
Production adapter against the reference scorer	maximum posterior delta 9.06e-6 against an allowed 1e-4; zero stamp flips under both threshold tables across 1,300 rows
Local CPU scoring rate	3.74 passages per second at batch 16 over 5,298 rows, peak resident set 4.18 GB

The compression interval spans zero, so INT8 is not measurably worse than FP32 on that panel. That read is a diagnostic: it carries no promotion authority and set no thresholds.

The scoring rate above comes from the run that produced the compression score receipt 5505e117…, on this artifact, through the production CPU path, as an aggregate over a whole panel.

Provider qualification (2026-09-06, ONNX Runtime 1.24.4, one NVIDIA RTX 3060 Ti with 8 GB) ran the same graph through the production adapter on three execution providers, with CUDA's TensorFloat-32 disabled (enabled, posteriors drifted 7.5e-4 from the CPU reference). Every matrix product stays on the accelerator; the only CPU-resident work under CUDA or DirectML is shape bookkeeping and the rank-0 scalars of the attention scale.

Provider	Posterior delta vs CPU (418 passages)	Stamp flips	Single passage p50	Batched rate
CPU	reference	0	331 ms	1.5 passages/s
CUDA	2e-6	0	19 ms	56 passages/s
DirectML	3e-6	0	74 ms	33 passages/s

Batched rates use eight-row batches planned against the device's free memory: throughput is flat beyond four rows on both accelerators, and larger batches at the 768-token ceiling exceed 8 GB and page silently on Windows. Device memory per row at 768 tokens is about 208 MiB on CUDA and 277 MiB on DirectML above a resident session of 657 MiB and 481 MiB respectively.

Evidence status

Evidence	Status
Promotion results, gates, and calibration	as recorded from the sealed 2026-08-12 read
Artifact identity, size, and quantization settings	verified 2026-09-04 against the quantization receipt
Compression equivalence	as recorded; diagnostic authority only
Production-adapter parity	as recorded from the promotion read
Linear baseline	re-run 2026-09-04 from the recorded inputs; byte-identical
Figures	regenerated 2026-09-04 from the recorded inputs; byte-identical
Previous-classifier identity	verified 2026-09-04 against the staged bundle's own config
Frontier-model comparisons	as recorded; single runs on a subsample that is not independent of the promotion read
Serving throughput	3.74 passages per second, as recorded from the scoring run bound to the compression score receipt
Per-passage latency percentiles	not measured

Limitations, ranked

1. Labels are model judgments. All scores measure agreement with a frozen frontier-model instrument. There is no human-adjudicated answer key, by the operator's explicit decision after the hand-labeling trial described above. Resolving evidence would be a human-adjudicated sample; none is planned.
2. Panels are generated text. Absolute performance on unrelated real documents is unmeasured for this artifact. Resolving evidence would be a multi-domain real-document panel labeled under the same protocol.
3. Three families in the promotion panel. The reported intervals capture sampling noise within three similar generated families, not variation across domains. More families would widen and honest-size the intervals.
4. No seed replicate. Every winner was trained once. Hardware and compute budget, not design, set that limit; the smallest selection margins above (0.0042 between backbones, 0.0005 for the curriculum) are within a plausible seed effect.
5. Lexical headroom is thin. A linear model sits 0.029 macro average precision below this model. The advantage is real but lives at high recall on decision and procedure, and should be read that way.
6. Frontier comparisons are single runs on a non-independent subsample with coarse external confidences.
7. Decision stays the hardest facet. 398 of the 1,300 promotion rows mention a decision without making one; that boundary is where the remaining error concentrates.
8. Serving cost is measured on one machine. The provider table in the runtime section comes from a single 8 GB NVIDIA card and a four-core CPU budget; other hosts will land elsewhere, and cold-start cost is not separated from warm batches.
9. Not yet the shipped default. The artifact is promotion-qualified; the activation, restamp, and rollback steps are separate operations.

Reproducibility

• Base model: knowledgator/gliclass-base-v3.0, revision pinned in gliclass_final_fit_campaign.json.
• Training rows: 59,886; manifest and lane digests in gliclass_final_fit_campaign.json and history/gliclass_std_base_v3_5facet_promotion_results.json.
• Promotion protocol: gliclass_std_base_v3_5facet_promotion.json (frozen 2026-08-12, seed 20260812, 10,000 family-cluster draws). Three digests in the results record do not reproduce from anything published or retained. promotion_plan_sha256 describes the private sealed plan, not this tracked public-safe copy. panel_sha256 and predictions_sha256 were transcribed faithfully from the sealed promotion report, but the private panel and predictions files that survive today hash to different values, so the exact bytes the sealed read scored are gone. The results themselves are the record.
• Calibration and thresholds: gliclass_std_base_v3_5facet_calibration.json, gliclass_std_base_v3_5facet_thresholds.json; fitted values in the promotion results record.
• Artifact: model.onnx SHA-256 690e50920e7780db5ecd14e4b209f0d3c86199214063e8bb59d399c93861324c, 452,812,018 bytes; candidate manifest ed8c1f8febe961624a698c97a3035e8ca5caa582718fd5a8f93f962c8106b942.
• Baselines: history/linear_baseline_results.json, reproduced byte-identical from the promoted training rows and the frozen evaluation lane with python -m classifier.scripts.qualification.linear_baseline --train <private>/classifier/campaigns/gliclass_standard_base_v3_final_fit_v2_training/train.jsonl --panel <private>/source_allocations/classifier_final_repartition_v1/lanes/classifier-evaluation.jsonl. The external-model protocols and results sit under history/. Those comparison plans pin the SHA-256 of the four scripts that produced them, and two of the four — eval/scripts/decision_grade_runner.py and eval/scripts/isolated_codex.py — have changed since. The plans therefore no longer load and are sealed records of what was run, not re-runnable commands.
• Figures: all three regenerate byte-identical with python eval/classifier/scripts/qualification/figures.py against the promotion run's private predictions.json, panel.json, and linear-baseline-scores.json.
• Entry point: python -m classifier.scripts.promotion.evaluation, which reproduces the plan's live bindings and verifies each against its recorded digest.

License and attribution

This derivative is published under the Apache License, Version 2.0, following the upstream model. It is a modified derivative of knowledgator/gliclass-base-v3.0 (Apache-2.0, revision 77a70e6cd52e602ed18184ef37d18bdd3741e3d5), which builds on microsoft/deberta-v3-base (MIT). Neither upstream author endorses this derivative. The changes — a supervised five-facet fine-tune, an ONNX export, INT8 quantization of the token-embedding table, and per-facet calibration — are listed in the NOTICE file that accompanies this model.