Source model card: Falconsai/proof_v2 @ main, carried verbatim below. Its licence is the repository's. The Model Surgeon record follows it.

Falconsai/proof_v2

View in Model Surgeon

An intentional decision model for the edge. A ModernBERT-base encoder carries a zero-shot listwise generalist and three distilled specialist heads (support intents, code language and reasoning), each behind its own step-function gate. You supply a state, a question and a closed set of options; it returns a calibrated probability for each option and names the head that answered.

falconsproof v2.0 is the successor to Falconsai/proof_V_1. It swaps DistilBERT for ModernBERT, adds code and reasoning specialists, and trains on a code-heavy mix of 19 tasks (73.4% of training decisions are code). It powers the IntFalcon Decision Lab.

Read this first: the gates in this checkpoint are closed. The validation search found no gate setting that beat the generalist, so every gate kept its closed value (τ = κ = μ = 1.01). Every answer in this checkpoint comes from the generalist, and all the test results below are the generalist's. The specialist heads are trained, calibrated and available for inspection (§5.4), and on some tasks one alone is stronger. The intent specialist, for example, scores 99.2% on Bitext against the generalist's 95.8%. Re-tuning the gates (§13) is the most direct improvement available.

Status of the numbers. Every figure here comes from this checkpoint's falconsproof_report.json: one training run with the small preset (up to 500 training decisions per source and task, 1 epoch per stage, seed 42), trained on an NVIDIA GeForce RTX 5090 Laptop GPU in bfloat16.

---

Table of contents

1. Model summary
2. Results at a glance
3. Model details
4. Intended uses and out-of-scope uses
5. How to get started
6. Architecture
7. Training data
8. Training procedure
9. Calibration, fidelity and gates
10. Evaluation
11. Comparison with v1
12. Bias, risks and limitations
13. Recommendations
14. Environmental impact
15. Technical specifications
16. Files in this repository
17. Versioning
18. Citation and references
19. Model card authors and contact

---

1. Model summary

Task	Closed-set decisions: given a state (text or code), a question and 2–20 options, return a calibrated probability per option
Backbone	answerdotai/ModernBERT-base: 22 layers, hidden size 768, 8,192-token capable; trained here at 384 tokens
Parameters	≈ 151.4M including all heads
Generalist	Listwise cross-encoder option head: one relevance logit per (question + state, option) pair
Specialists	intent (15 support intents), code (6 languages), reasoning (entailment of each option). Each is distilled from its own teacher, then frozen
Router	One step-function gate per specialist; the most confident passing specialist answers, otherwise the generalist. All gates are closed in this checkpoint
Calibration	One temperature per head: generalist T = 1.197; intent 2.030, code 3.578, reasoning 5.530
Inference cost	Two encoder forward passes per call, however many questions are asked about the same state
Output	Probabilities, the chosen option, the answering head, and every gate's inputs against its thresholds
Language	English, plus code in Go, Java, JavaScript, PHP, Python, Ruby (and C for vulnerability detection)

The model has no generative component. It can only rank the options you give it.

---

2. Results at a glance

Test accuracy on 5,096 decisions from 23 sources and tasks, 4 of them held out:

Domain	n	falconsproof	ECE
code	3536	0.896	0.013
support	120	0.958	0.033
intents	240	0.867	0.013
reasoning	1200	0.544	0.037
all sources	5096	0.813	0.008

Strong (≥ 88%)	Weak (near chance)
Code language ID 99.7% · MBPP task → solution 99.2% · code → description 96.9% · description → code 96.1% · Bitext support routing 95.8% · SNLI 90.8% · function naming 90.1% · held-out Banking77 88.3%	GSM8K 27.5% (chance 25%) · OpenBookQA 29.2% (25%) · ARC-Challenge 30.8% (25%) · BigCloneBench 38.3% (50%) · MBPP bug spotting 47.5% (≈ 40%) · Devign 54.2% (50%) · MultiNLI claims 49.2% (33%)

Calibration is excellent. Overall expected calibration error (ECE) is 0.008, so a stated confidence of 80% means about 80% accuracy on data like this test set. Answers are also independent of option order: accuracy after reshuffling the options is identical on every source.

---

3. Model details

Field	Value
Model name	falconsproof v2.0.0
Repository	Falconsai/proof_v2
Developed by	Falconsai
Model type	Encoder-only decision model: listwise cross-encoder plus distilled classifier heads with thresholded routing
Backbone	answerdotai/ModernBERT-base (revision not pinned)
Teachers	intent: Falconsai/intent_classification @ 630d0d4 · code: huggingface/CodeBERTa-language-id · reasoning: cross-encoder/nli-deberta-v3-small
Language	English and six programming languages
License	Apache-2.0 for the weights and code (ModernBERT-base is Apache-2.0). Check each teacher's and dataset's own license before redistribution
Custom code	Yes: falconsproof_modeling.py ships with the weights and holds the model and all decision logic. It is loaded with importlib, not trust_remote_code
Training notebook	falconsproof_v2.ipynb

---

4. Intended uses and out-of-scope uses

Intended

Use	Measured evidence
Support and intent routing, including taxonomies defined at request time	Bitext 95.8%, CLINC150 85.0%, held-out Banking77 88.3%
Code understanding against a fixed menu: language ID, matching code to descriptions, choosing an implementation for a task	99.7%, 96.9%, 99.2%
Statement verification against a short text ("which statement must be true / contradicts")	SNLI 90.8% / 89.2%
Selective automation in agents: act on confident answers, defer the rest	ECE 0.008 makes confidence thresholds meaningful

Out of scope

• Arithmetic and multi-step reasoning. GSM8K is at chance (27.5%), and science and commonsense multiple choice are weak.
• Security or correctness gating of code. Vulnerability detection (54.2%), clone detection (38.3%) and spotting single-token bugs (47.5%) are near or below chance. Don't use it as a code reviewer or a security scanner.
• Open-ended questions. It always picks one of your options; add "none of these" explicitly if that's a possible answer.
• Long inputs. Anything beyond 384 tokens (state and option together) is truncated.
• Non-English text, and high-stakes decisions without human oversight (medical, legal, financial, employment, safety-critical).

---

5. How to get started

5.1 Install

pip install torch "transformers>=4.48,<5" safetensors huggingface_hub numpy

ModernBERT needs transformers 4.48 or newer. This checkpoint was saved with transformers 4.57.1.

5.2 Load

import importlib.util
from huggingface_hub import snapshot_download

path = snapshot_download("Falconsai/proof_v2")
spec = importlib.util.spec_from_file_location("falconsproof_modeling", f"{path}/falconsproof_modeling.py")
fpm = importlib.util.module_from_spec(spec); spec.loader.exec_module(fpm)

model, tokenizer = fpm.FalconsProof.load(path)          # cuda if available, else cpu
print(model.config["version"], [s["name"] for s in model.specialists])

5.3 Decide (with question fanout)

result = fpm.decide(model, tokenizer,
    state="def mean(xs):\n    return sum(xs) / len(xs)",
    questions=[
        {"question": "Which programming language is this?", "options": ["Python", "Ruby", "Go"]},
        {"question": "What does this function do?",
          "options": ["Computes the average of a list", "Sorts a list", "Reverses a string"]},
    ])
for r in result["results"]:
    print(r["question"], "->", r["choice"], r["probs"], "via", r["route"])
print(result["forward_passes"], "forward passes")      # 2, however many questions

Each result carries choice, probs, route ("generalist" or a specialist's name), the generalist's own distribution, and one gates row per specialist with conf/tau, affinity/kappa, min_map/map_min, collision and passed.

5.4 Read each head directly

analyze() returns every head's view, including the specialists that the closed gates keep from answering:

out, meta = fpm.analyze(model, tokenizer, [{
    "state": "I forgot my password and can't sign in.",
    "question": "Which team should handle this message?",
    "options": ["recover password", "shipping", "invoicing"]}])
o = out[0]
print("answered by:", o["route"], "| generalist:", o["gen_probs"].round(3))
for name, view in o["views"].items():
    print(f"{name:10s} choice={view['choice']} conf={view['conf']:.3f} affinity={view['affinity']:.3f}")

5.5 Open a specialist's gate (optional)

Gates are plain numbers in model.config. To let the intent specialist answer confidently mapped support questions:

spec = next(s for s in model.config["specialists"] if s["name"] == "intent")
spec["gate"] = {"tau": 0.90, "kappa": 0.50, "map_min": 0.70}      # choose from your own validation data

Validate any hand-set gate on labelled data before relying on it. §13 describes the proper re-tuning.

---

6. Architecture

                         ┌─────────────── ModernBERT-base encoder (shared) ───────────────┐
 state, option texts ────┤─► mean-pool ─► intent head   (15 labels)  ◄ Falconsai/intent_classification
                         │             └► code head     (6 labels)   ◄ huggingface/CodeBERTa-language-id
 (question | state,      │                                                                  
   option) pairs ────────┤─► mean-pool ─► reasoning head (contradiction/entailment/neutral) ◄ cross-encoder/nli-deberta-v3-small
                         │             └► option head   (1 logit per option): the generalist
                         └────────────────────────────────────────────────────────────────┘
   gate_k = H(conf_k − τ_k) · H(affinity_k − κ_k) · H(map_k − μ_k) · [no collisions]
   answer = the most confident specialist whose gate passes, otherwise the generalist

Head	Kind	Reads	Affinity signal
intent	label	the state; each option is mapped to one of its labels (exact name, alias or its own head)	coverage: the share of its belief on the offered labels
code	label	the same; aliases such as golang → go and js → javascript	coverage
reasoning	pair	each (state, option) pair, scored for entailment	support: the entailment probability of its top option
generalist	listwise	each (question | state, option) pair	none (always eligible)

All heads are two-layer MLPs (768 → 768 → GELU → dropout → output) on mean-pooled encoder states.

---

7. Training data

Every example is a decision (state, question, options, answer, plus source, task, domain), with options shuffled. In total there are 18,795 training, 4,520 validation and 5,096 test decisions; 73.4% of the training decisions are code.

7.1 Sources and tasks

Domain	Source	Tasks
code	CodeXGLUE code-to-text (Go, Java, JavaScript, PHP, Python, Ruby)	language ID; code → description; description → code; function naming (name masked as ___). Docstrings are stripped so descriptions can't be matched by string
code	CodeXGLUE Devign (C)	vulnerability detection; C language ID
code	CodeXGLUE BigCloneBench (Java)	clone detection
code	MBPP (Python)	task → solution; bug spotting: the reference solution against single-fault mutants (flipped comparison, off-by-one, and↔or, min↔max and similar) that still parse
code	HumanEval (held out)	the correct completion against mutated completions
support	Bitext customer support	routing to Falconsai intents (the Bitext intents are mapped empirically, §7.3)
intents	CLINC150; Banking77 (held out)	intent names as runtime-defined options
reasoning	CommonsenseQA, OpenBookQA, SciQ, BoolQ, GSM8K; ARC-Easy and ARC-Challenge (held out)	multiple choice, yes/no, numeric answers with near-miss distractors
reasoning	SNLI, MultiNLI	which statement must be true or contradicts the text; does a claim follow

Held-out sources were never used for training, calibration or gate tuning. Check each dataset's card for its license before you redistribute derived data.

7.2 Decisions per source and task

Source / task	Train	Val	Test
bigclonebench/clone	500	120	120
codexglue/code_to_doc	3,000	720	720
codexglue/doc_to_code	3,000	720	720
codexglue/func_name	2,968	720	720
codexglue/lang_id	3,000	720	720
devign/lang_id	224	56	56
devign/vulnerability	500	120	120
humaneval/completion	0	0	120
mbpp/bugspot	229	54	120
mbpp/solution	374	90	120
bitext/route	500	120	120
banking77/intent	0	0	120
clinc150/intent	500	120	120
arc_challenge/mcq	0	0	120
arc_easy/mcq	0	0	120
boolq/yes_no	500	120	120
commonsense_qa/mcq	500	120	120
gsm8k/math	500	120	120
mnli/claim	500	120	120
openbookqa/mcq	500	120	120
sciq/mcq	500	120	120
snli/contradicts	500	120	120
snli/must_be_true	500	120	120
Total	18,795	4,520	5,096

Tasks built from the six-language corpus are capped per language, which is why they have 3,000 training decisions against 500 for other tasks.

7.3 Bitext → Falconsai label mapping

Each Bitext intent is mapped to the intent teacher's majority label if at least 70% of 64 examples agree. All 27 Bitext intents passed, covering 14 of the 15 labels; appointment has no Bitext equivalent.

The 27 mappings

Bitext intent	Falconsai label
cancel_order	cancellation
change_order	ordering
change_shipping_address	shipping
check_cancellation_fee	cancellation
check_invoice	invoicing
check_payment_methods	billing and payment
check_refund_policy	returns and refunds
complaint	complaints and feedback
contact_customer_service	speak to person
contact_human_agent	speak to person
create_account	edit account
delete_account	delete account
delivery_options	delivery information
delivery_period	delivery information
edit_account	edit account
get_invoice	invoicing
get_refund	returns and refunds
newsletter_subscription	subscription
payment_issue	billing and payment
place_order	ordering
recover_password	recover password
registration_problems	registration problems
review	complaints and feedback
set_up_shipping_address	shipping
switch_account	edit account
track_order	ordering
track_refund	returns and refunds

7.4 Distillation sets (Stage A)

Each specialist learns from 2,500 teacher-labelled inputs, with 300 more held back to measure fidelity. About 15–25% of each set is deliberately outside the specialist's domain, so the specialist also learns how its teacher behaves off-domain, which is exactly what the gates rely on.

---

8. Training procedure

Stage	What trains	Loss
A: distil the specialists	Encoder (except embeddings) and the three specialist heads	T² · KL(teacher ‖ student) at T = 2.0, rotating between specialists
B: train the generalist	Option head and encoder layers 7–22 (embeddings and layers 1–6 frozen); specialist heads frozen	Listwise CE over each decision's options + 1.0 × distillation on the frozen heads (the anchor, which stops the encoder drifting away from the specialists)
Calibrate	One temperature per head	NLL on validation decisions
Gate search	τ, κ, μ per specialist	Coordinate ascent over 41 × 21 × 5 threshold grids, maximising domain-balanced validation accuracy

Hyperparameter	Value
Preset	small
Epochs, stage A / stage B	1 / 1
Batch	16 decisions (effective 16) · distillation 64
Learning rate, encoder / heads	2e-05 / 0.0005, linear schedule, 6% warmup, AdamW (weight decay 0.01), gradient clipping 1.0
Maximum length	384 tokens
Options per decision	2–5 when sampled; all choices for multiple-choice sources
Precision	bfloat16 autocast, TF32 matmuls
Checkpoint selection	Best generalist validation accuracy
Hardware	NVIDIA GeForce RTX 5090 Laptop GPU (25.7 GB)
Software	Python 3.14.4, PyTorch 2.11.0+cu128, transformers 4.57.1

---

9. Calibration, fidelity and gates

9.1 Temperatures and specialist fidelity

Fidelity is argmax agreement between a specialist and its teacher on held-back distillation inputs.

Specialist	Kind	Temperature	Fidelity after stage A	Fidelity after stage B
intent	label	2.030	88.0%	96.0%
code	label	3.578	90.3%	88.7%
reasoning	pair	5.530	43.3%	70.0%
generalist	listwise	1.197

• The specialists were over-confident (every temperature is well above 1), the reasoning head most of all (T ≈ 5.5). Calibration softens them so that one threshold means the same across heads.
• Fidelity rose in stage B, because the anchor kept distilling while the encoder improved. The intent and code heads match their teachers closely.
• The reasoning head only partly learned its teacher (70%). One epoch of the small preset wasn't enough to distil a DeBERTa NLI model, which helps explain why its gate stayed closed.

9.2 Gates

Specialist	τ (confidence)	κ (affinity)	μ (mapping)	State
intent	1.01	1.01	1.01	closed
code	1.01	1.01	1.01	closed
reasoning	1.01	1.01	1.01	closed

The search started with every gate closed and kept a setting only if it improved domain-balanced validation accuracy. It ran from 0.8526 to 0.8526: no change, so every gate stayed closed.

The test data suggests why. Where a specialist is strong, the generalist is nearly as strong (Bitext 99.2% against 95.8%; SNLI must-be-true 94.2% against 90.8%). The domain-balanced objective weighs support as one domain among four, so opening a gate either gains too little or also lets the specialist answer questions it shouldn't. The code specialist (89.9% on language ID) is outright weaker than the generalist (99.7%).

---

10. Evaluation

10.1 Metrics

Metric	Definition
falconsproof	Accuracy of the gated model, the one you deploy. It equals the generalist's here, since all gates are closed
intent / code / reasoning only	Accuracy if that specialist alone answered everything. Only meaningful on its own domain; elsewhere it's shown for completeness
Chance	Expected accuracy of a random pick, from the number of options (approximate where it varies)
ECE	Expected calibration error of the final probabilities (10 bins)
Perturbed	Accuracy after the options are reshuffled: identical to falconsproof on every source, so it isn't repeated below

10.2 Results per source and task

Domain	Source / task	n	Chance	falconsproof	intent only	code only	reasoning only	ECE
code	devign/lang_id	56	≈0.32	1.000	0.339	0.411	0.589	0.064
code	codexglue/lang_id	720	≈0.32	0.997	0.358	0.899	0.774	0.015
code	mbpp/solution	120	≈0.36	0.992	0.408	0.408	0.858	0.040
code	codexglue/code_to_doc	720	≈0.32	0.969	0.375	0.304	0.912	0.008
code	codexglue/doc_to_code	720	≈0.36	0.961	0.396	0.365	0.918	0.015
code	codexglue/func_name	720	≈0.32	0.901	0.362	0.300	0.867	0.027
code	devign/vulnerability	120	≈0.50	0.542	0.450	0.575	0.525	0.084
code	mbpp/bugspot	120	≈0.40	0.475	0.442	0.442	0.508	0.059
code	bigclonebench/clone	120	≈0.50	0.383	0.433	0.433	0.225	0.200
code	humaneval/completion (held out)	120	≈0.33	0.575	0.375	0.367	0.583	0.089
support	bitext/route	120	≈0.32	0.958	0.992	0.417	0.875	0.033
intents	clinc150/intent	120	≈0.32	0.850	0.442	0.358	0.775	0.047
intents	banking77/intent (held out)	120	≈0.32	0.883	0.475	0.242	0.850	0.046
reasoning	snli/must_be_true	120	≈0.40	0.908	0.408	0.300	0.942	0.029
reasoning	snli/contradicts	120	≈0.40	0.892	0.333	0.292	0.033	0.063
reasoning	boolq/yes_no	120	≈0.50	0.717	0.475	0.475	0.725	0.126
reasoning	sciq/mcq	120	≈0.25	0.692	0.250	0.258	0.675	0.142
reasoning	mnli/claim	120	≈0.33	0.492	0.325	0.308	0.417	0.092
reasoning	commonsense_qa/mcq	120	≈0.20	0.442	0.225	0.183	0.358	0.094
reasoning	openbookqa/mcq	120	≈0.25	0.292	0.200	0.167	0.342	0.149
reasoning	gsm8k/math	120	≈0.25	0.275	0.258	0.317	0.300	0.025
reasoning	arc_easy/mcq (held out)	120	≈0.25	0.425	0.225	0.308	0.458	0.046
reasoning	arc_challenge/mcq (held out)	120	≈0.25	0.308	0.258	0.258	0.250	0.129

10.3 Key findings

1. Code understanding is the strongest area. Language ID (99.7%), task → solution (99.2%), code ↔ description (about 96–97%) and function naming (90.1%) are all far above chance, and the held-out HumanEval completion task reaches 57.5% against a chance level of about 33%.
2. Fine-grained code judgement is not learned. Clone detection (38.3%, below chance), bug spotting (47.5%) and Devign (54.2%) show the model reads what code is about, not whether it is correct.
3. Intent generalisation is strong. Held-out Banking77 scores 88.3% and CLINC150 85.0%, well above chance (about 32%), with a label space never seen in training.
4. Reasoning is mixed. Entailment-style tasks work (SNLI about 90%, SciQ 69.2%), but arithmetic (GSM8K 27.5%), OpenBookQA and ARC-Challenge are at or near chance.
5. Specialists outperform the generalist in places, but the closed gates stop them answering: intent on Bitext (+3.3 pts), reasoning on SNLI must-be-true (+3.3 pts). The reasoning head also shows why gates matter: asked "which statement contradicts the text", it picks the entailed statement (3.3%).
6. Calibration is reliable. ECE is 0.008 overall and at most 0.200 on any single source.

---

11. Comparison with v1

The same sources appear in both test sets, but they are different random samples (v1 used 300 decisions per source with 2–6 options, v2 used 120 with 2–5), so treat the differences as indicative.

Source	v1 (proof_V_1)	v2	Change
bitext	0.973	0.958	-0.015
clinc150	0.463	0.850	+0.387
banking77 (held out)	0.450	0.883	+0.433
commonsense_qa	0.250	0.442	+0.192
openbookqa	0.267	0.292	+0.025
arc_easy (held out)	0.313	0.425	+0.112

v2 roughly doubles accuracy on unfamiliar intent taxonomies (CLINC150, Banking77) and improves multiple choice. v1 remains slightly better on in-domain Bitext routing, where its specialist gate was open. v2 also adds the whole code domain, which v1 didn't cover.

---

12. Bias, risks and limitations

• Gates closed. All answers come from the generalist. The specialists add no accuracy in this checkpoint until their gates are re-tuned.
• Light training. The small preset (1 epoch per stage, at most 500 decisions per task) and a reasoning head at 70% teacher fidelity leave room for improvement.
• Closed world. The model always picks one of your options.
• Truncation. 384 tokens total; long code or documents lose content.
• Code correctness. It can't tell correct code from subtly broken code (bug spotting 47.5%). Don't use it to approve code.
• Distribution-dependent calibration. ECE was measured on this test mix; re-check it on your own traffic.
• Data provenance. Training data is English and mostly templated, crowd-sourced or scraped from public code. Biases in the source datasets, the teachers and ModernBERT's pre-training can carry into decisions.
• Automation risk. Automatic routing can systematically misroute users whose phrasing differs from the training data (dialects, non-native speakers, assistive phrasing). Monitor misroutes by group where possible.

---

13. Recommendations

• Re-tune the gates. Run the gate search on a larger validation set, or on labelled examples of your own traffic, with domain weights that reflect your use. The intent gate is the obvious first candidate. The gates are plain values in falconsproof_config.json.
• Retrain with the standard preset (up to 2,500 decisions per task, 2 stage-B epochs, 512 tokens) to strengthen the reasoning head and the weak code-judgement tasks.
• Use deferral. Act on high-confidence answers and send the rest to a human or an LLM; the low ECE makes this dependable.
• Evaluate on your own data (50–500 labelled decisions) before deploying, especially for any code or reasoning use.
• Log the route, confidence and model revision with every decision.

---

14. Environmental impact

Hardware	NVIDIA GeForce RTX 5090 Laptop GPU (25.7 GB), bfloat16
Training time	not recorded: fill in from your run
Region / provider	local workstation
Estimated emissions	estimate with the ML CO2 Impact calculator once the training time is known

Inference needs no GPU: two forward passes of a 151M-parameter encoder per call.

---

15. Technical specifications

Pooling	Attention-masked mean of the final hidden states
Pair format	"{question} | {state}" [SEP] "{option}", truncated longest_first to 384 tokens
Inference	Pass 1: the state and unique option texts through the label specialists. Pass 2: all (question + state, option) pairs through the generalist and the reasoning head
Router	Most confident passing specialist, else the generalist
Serialisation	encoder/ (ModernBERT weights, config, tokenizer), heads.safetensors, falconsproof_config.json
torch.compile	Disabled (reference_compile = False) so the model runs on Windows, CPU and GPU alike
Determinism	Bit-for-bit repeatable in eval mode with the same hardware and library versions

---

16. Files in this repository

File	Contents
encoder/	ModernBERT-base weights, config and tokenizer, fine-tuned
heads.safetensors	The option head and the three specialist heads
falconsproof_config.json	Version, maximum length, template, temperatures, specialists (labels, aliases, teachers) and gates
falconsproof_modeling.py	The model and all decision logic: FalconsProof, analyze, decide, similarity, route, gate_report
falconsproof_report.json	Training configuration, data counts, fidelity, gate search and all test results
README.md	This model card

---

17. Versioning

	v1 (proof_V_1)	v2.0 (this model)
Backbone	DistilBERT, 128 tokens	ModernBERT-base, 384 tokens (8,192 capable)
Specialists	1 (the original Falconsai head)	3, each distilled from its own teacher and frozen
Gates	One, open	One per specialist, closed in this checkpoint
Training data	4 sources	19 tasks from 13 sources, 73.4% code
Decision code	In the notebook	Shipped in falconsproof_modeling.py

Changelog. v2.0.0: first release, trained with the small preset (seed 42).

---

18. Citation and references

@misc{falconsai_proof_v2_2026,
  title        = {falconsproof v2.0: distilled specialists and a listwise generalist behind step-function gates},
  author       = {{Falconsai}},
  year         = {2026},
  howpublished = {\url{https://huggingface.co/Falconsai/proof_v2}},
  note         = {ModernBERT-base backbone; successor to Falconsai/proof_V_1}
}

Methods. Warner et al. (2024), Smarter, Better, Faster, Longer: A Modern Bidirectional Encoder (ModernBERT). Hinton, Vinyals and Dean (2015), Distilling the Knowledge in a Neural Network. Li and Hoiem (2016), Learning without Forgetting. Nogueira and Cho (2019), Passage Re-ranking with BERT. Cao et al. (2007), Learning to Rank: From Pairwise Approach to Listwise Approach. Guo et al. (2017), On Calibration of Modern Neural Networks. Geifman and El-Yaniv (2017), Selective Classification for Deep Neural Networks.

Data. Lu et al. (2021), CodeXGLUE. Austin et al. (2021), Program Synthesis with Large Language Models (MBPP). Chen et al. (2021), Evaluating Large Language Models Trained on Code (HumanEval). Larson et al. (2019), CLINC150. Casanueva et al. (2020), Banking77. Talmor et al. (2019), CommonsenseQA. Mihaylov et al. (2018), OpenBookQA. Welbl et al. (2017), SciQ. Clark et al. (2019), BoolQ. Cobbe et al. (2021), GSM8K. Bowman et al. (2015), SNLI. Williams et al. (2018), MultiNLI. Clark et al. (2018), ARC. Bitext, Customer Support LLM Chatbot Training Dataset.

---

19. Model card authors and contact

Written by the Falconsai team. Please report issues, misroutes or evaluation results through the Community tab of this repository.

---

This card is generated from the surgical record itself; the package's lineage.intoto.jsonl is the signed source of truth (verify it free at the Surgeon's public verifier or with the bundled verify_attestation.py).

Architecture

• Identification: NLP · Small Language Model (SLM) (62% confidence)
• Source format: safetensors · Intended task: not declared
• config.json: the repo's config.json, edited
• Source license: apache-2.0
• Lineage chain: 1 surgery (no prior attestation reachable) · Falconsai/proof_v2
• Post-surgery totals: 149,014,272 parameters · 134 tensors
• Compute estimate: 14.118027 GFLOPs (comparison metric, not a measurement)

Provenance & operations

• Parents: Falconsai/proof_v2/model.safetensors
• Operations performed: load×1
• Weight merges recorded: 0
• Quantized tensors (F32→F16): 0

Surgery Log (ordered)

1. load — hub:Falconsai/proof_v2/model.safetensors (596.1 MB, safetensors)

Validation

• Tissue imaging: not run
• Structural integrity is testable offline via the packaged load_and_test.py.

Compliance note

The signed attestation + this card together document model composition, modification history, and validation evidence — the record structure technical-documentation obligations (e.g. EU AI Act Annex IV) ask for. This is evidence, not legal advice.

---

Operated with Model Surgeon — verify this package at https://surgeon.falcons.ai/verify © 2026 FALCONS.AI — Model Surgeon record format. The model weights remain their owner's.