betaFeedback

WorksComputer Science

A First Look at System One Decision Models for Malware Detection

Abstract

Malware detection needs scores calibrated at a fixed false positive rate (FPR) and decisions an analyst can read: feature-based detectors give the first, large language models (LLMs) on decompiled code the second, through generated text of uncalibrated confidence. System One decision models answer a typed question about a text with a probability over its declared answers in one forward pass. We present the first evaluation of these models for Windows Portable Executable malware detection, analyze how they decide, and propose S1Mal, an ensemble on the typed answers and the embedding of CLM-8B. In an isolated virtual machine, Ghidra and capa decompose each binary, and the host renders the records into a canonical textual state, a digest of headers, imports, MITRE ATT&CK capabilities and strings, optionally with decompiled functions, without class shortcuts. Three readouts score each model on the state: A0, the probability of one verdict question; A1, 32 atomic behavioral questions weighed by gradient-boosted trees; A2, heads on the model's state embedding. S1Mal feeds gradient-boosted trees with the atomic answers and the A2 score of CLM-8B. We evaluate CLM-8B, ten open decision models and two LLMs read through logits on BODMAS temporal splits, SOREL-20M out-of-distribution malware and 14,534 matched benign files. On BODMAS, A0 wastes the static evidence: its area under the receiver operating characteristic curve (AUROC) spans 0.4025-0.8590 across 13 models. A1 recovers it, raising every model's AUROC by +54.61% on average; A2 lifts CLM-8B by +0.2749 to 0.9943, above a combiner on digest facts (0.9901), and reaches 0.9853-0.9948 on nine open models. S1Mal reaches 0.9946 and detects 93.47% of the malware at a realized FPR of 1.45%, and 59.15% at 0.1% FPR on the test ROC curve, against 46.59% with A2. S1Mal gives analysts calibrated decisions, each with the atomic answers behind it.

Introduction

Windows malware detection is the first filter of endpoint products and security operations centers: a Portable Executable (PE) file is judged before it runs, at a volume where only very low false positive rates (FPRs) are tolerable [28]. Learned detectors on engineered features (e.g., LightGBM on EMBER [1, 14]) and networks on raw bytes (e.g., MalConv2 [34]) meet the throughput, but their scores carry no account of the evidence behind them, and their evaluation is fragile under temporal bias and drift [2, 4, 31].

Large language models (LLMs) that read decompiled code or static reports promise that account [6, 8]. They answer in generated text with a self-reported confidence, which is slow to produce, hard to calibrate and easy to steer with strings planted in the binary [9]. In September 2026 a new class of models appeared: System One decision models, which read a textual state and a typed question and return a probability over the declared answers in a single forward pass [33].1 Their first security evaluations cover agent actions, prompt injection, web requests and network traffic [7, 16, 19, 21]. To our knowledge, none gives them a malware file.

This work takes a first look at System One models as Windows PE malware detectors built on static analysis (Figure 1). It evaluates eleven of them, CLM-8B [18] and ten open decision models, on the same states and the same questions, next to two LLMs read through their answer tokens and a combiner on the digest facts. An isolated virtual machine decompiles each binary with Ghidra [27] and matches capa [24] rules, and the results are rendered into a canonical textual state from which the known class shortcuts are removed. On this evaluation we read every System One model through three readouts, each calibrated at a 1% FPR operating point: the probability of a single verdict question (A0), a gradient-boosted combiner over the answers to 32 atomic behavioral questions (A1), and heads trained on the model’s embedding of the state (A2). A0 and A1 are measured on all 13 models that read a prompt and A2 on CLM-8B and 9 open models, so that each design choice is tested across models. On CLM8B, which reads the most evidence of each file, the digest together with its decompiled functions, we build S1Mal, an ensemble that feeds gradient-boosted trees with the atomic answers and the score of heads trained on the embedding. The evaluation runs ten experiments, E1 to E10, each with its question and primary endpoint fixed before testing (Table 4): detection (E1, with E1b for heads on the open models), the parts of the state (E2) and the questions and combiner (E3) that carry the decision, calibration and abstention (E4), deployment on a laptop GPU (E5), stability across seeds and runs (E6), hallucination and invariance (E7), text planted in the binary (E8), temporal drift (E9) and transfer to out-of-distribution malware (E10).

Figure 1. Overview of the pipeline and of S1Mal.

Exp.QuestionPrimary endpoint
E1Do System One models detect malware, and what do their readouts add over the digest facts and over LLMs read through logits?TPR at τ1%\tau_{1\%} on TEST, with the realized FPR on BtestB_{\mathrm{test}}
E1bDo heads on the embedding of every open model add over its atomic answers?paired AUROC difference of A2 and A1 per model
E2Which parts of the state carry the decision?paired AUROC difference per level of the state
E3Which questions and which combiner serve the decision?paired AUROC difference per question design
E4Are the scores calibrated, and how much does abstention buy?paired ECE difference before and after recalibration
E5How do inference time, memory and energy on a laptop GPU compare with the workstation, and do the answers agree?equivalence of two serving paths of CLM-8B
E6How stable are the decisions across seeds and runs?decision flip rate of A2 between seeds
E7Do typed answers hallucinate, and do they resist meaning-preserving changes?rate of fabricated artifacts per negative regime
E8Does text planted in the binary steer the decision?paired change of TPR and FPR per condition
E9How does detection decay over the nine test months?area under time of the monthly TPR
E10Does detection transfer to SOREL-20M?TPR on the OOD set at the frozen τ1%\tau_{1\%}

Table 4. Experiments and primary endpoints.

The contributions of this work are:

  • A first look at System One decision models for Windows malware detection from static analysis, covering CLM-8B and ten open decision models next to a combiner on the digest facts and two LLMs read through logits, on BODMAS temporal splits, SOREL-20M out-of-distribution data and 14,534 matched benign files, with every readout measured on every model that reads a prompt and the state and the questions ablated on a development sub-sample. On the test split, a single verdict exploits the static evidence only in part, while readouts trained on the atomic answers or on the embedding draw much more signal from it: the atomic questions lift every model over the verdict, by +0.1143 to +0.5412 in AUROC, and heads on the embeddings of 9 open models reach 0.9853 to 0.9948, each above its atomic answers.

  • S1Mal, an ensemble on CLM-8B that feeds a gradient-boosted combiner of its atomic behavioral answers with the score of heads trained on its embedding, with calibration, a fixed operating point and abstention. It ranks the test files at an AUROC of 0.9946 and detects 59.15% of the malware at 0.1% FPR on the test ROC curve, against 46.59% for the heads alone, whose AUROC of 0.9943 already passes the combiner on the digest facts and the LLMs.

  • An isolated pipeline from binary to textual state, built on Ghidra decompilation and capa capabilities, whose canonicalization and leak guards remove the timestamp, toolchain, bitness and disarming shortcuts that separate the two classes.

  • A characterization of reliability and deployment: hallucination and invariance probes on typed answers, robustness to text planted in the binary, temporal drift, and the inference time, memory and energy of the models on a laptop GPU against a workstation.

The remainder of this paper is organized as follows. Section 2 reviews background and related works. Section 3 presents the ablation between the models and the S1Mal framework in full. Section 4 reports experimental results. Section 5 concludes with directions for future work. Appendix A describes the question bank.

Background and Related Works

Background

System One decision models. TypeSafe introduced System One models with Jev in September 2026, as models that make fast, structured decisions that software can use directly.1 A caller sends a textual state and typed question (e.g., a boolean, a choice among options or a score over levels) and receives a probability over the declared answers without any generated text [33]. The output is a number that a program can threshold, at the cost of one forward pass. Open models followed within weeks. Key-0.8B [29] and Strands Decider [36] add a pointer head to a small Qwen3.5 decoder adapted with LoRA. decider [26] fine-tunes all the weights of Qwen3.5 models of 0.8B to 4B parameters. Von [30] and Laya [22] are encoder models, Von with a head over option markers, and Liquid’s d1 models[2] build on LFM2.5. CLM-8B [18] takes a contrastive route, as CLAP [39] does for assembly and its descriptions: two heads on a frozen Qwen3-8B map the state and each candidate answer into one space, and the answer probability follows their cosine similarity (Eq. (1)).

Static analysis of PE files. A PE file declares its sections, imported functions, resources and entry points in its headers, which parsers (e.g., pefile [5]) read without running it. A decompiler (e.g., Ghidra [27]) goes further: it recovers the functions of the machine code, their call graph and an approximate C rendering of their bodies. capa [24] matches rules on that program to name capabilities (e.g., injecting code into another process or encrypting files) and maps them to MITRE ATT&CK techniques and MBC behaviors. These artifacts are what a malware analyst reads, and they are the evidence that our textual states carry.

Related Works

Learned detectors. EMBER [1] established LightGBM on engineered PE features as the reference detector, and EMBER2024 [14] reports a TPR of 94.48% at 1% FPR for a LightGBM trained on six file formats from September 2023 to September 2024 and tested on the following twelve weeks. BODMAS [43] and SOREL-20M [12] release timestamped malware with features, SOREL-20M also with baseline models, and MalConv2 [34] learns directly from the raw bytes of whole binaries. The evaluation of these detectors is fragile. TESSERACT [31] shows how spatial and temporal bias inflate results, Transcendent [4] and CADE [44] detect and reject drifting samples, Nguyen et al. [28] stress that deployment needs thresholds fixed on validation data at very low FPR, and Arp et al. [2] list ten pitfalls of machine learning in security. This study adopts these rules: time-ordered splits, thresholds fixed on validation data and the FPR realized on the test files.

LLMs on static artifacts. Chawla and Prasad [6] prompt LLMs with Ghidra pseudo-C of Windows executables: Gemini 2.5 Pro reaches 80.1% accuracy against 98.5% for XG-Boost, and 64.2% on samples from 2025, with no FPR or confidence reported. PE2Prompt [37] turns EMBER features into zero- and few-shot prompts and reaches 49% to 73% accuracy. Turkmen and Raina [38] combine Ghidra and RetDec views of ELF objects without model probabilities or thresholds. MARS [8], the closest work, builds evidence bundles from headers, sections, imports, strings, YARA matches and optional Ghidra functions, and asks generative LLMs for a four-label verdict in JSON, or for behavioral claims that an external rule policy scores: it reaches 85.9% to 96.2% accuracy on 1,195 PE and ELF binaries, with a self-reported confidence that is never analyzed for calibration. ALIBI [9] shows the weakness of such verdicts: a legitimacy narrative planted in a section that never runs flips 30 of 35 verdicts of Gemini 2.5 Pro. Kurlandski et al. [17] pretrain malware language models on the bytes, disassembly and decompiled code of about 800,000 deduplicated PE files, with a detection AUROC of up to 0.996 on decompiled code, and AsmRAG [15] classifies files by nearest-neighbor votes over Qwen3-Embedding vectors of their Ghidra assembly functions, with an F1 of 96.0%. Unlike these works, this study reads a probability from typed answers in one forward pass, calibrates it, fixes its operating point at 1% FPR on held-out validation files, and removes the class shortcuts of the textual input before any model sees it.

Decision models in security. The first security studies of System One models appeared alongside the models. Sec-Jev [7] specializes Kev-style decision models for 14 security tasks, from IoT traffic to authentication logs and agent actions, and tests their transfer on IoT-23 malware traffic, so that, to our knowledge, decision models have met malware traffic but not malware files. Liu [21] evaluates Jev, Laya, decider and other models on agent-security decisions and finds that a low average calibration error can hide confident errors on attack groups. Lan et al. [19] measure an ECE of 0.541 for Jev on pooled prompt-injection data, where a miss rate of at most 1% requires escalating 92.55% of the inputs. Kisielowicz et al. [16] hold out attack families of web requests and recalibrate before thresholding, the methodological twin of this study. Rafe and Das [33] find that trained classifiers still lead where labels exist and that swapping yes and no flips 50.5 answers in a hundred for Jev. This study brings these models to PE files, and measures on malware evidence from static analysis the calibration, polarity and invariance concerns that these studies raise.

Hallucination and prompt sensitivity. POPE [20] probes hallucination with yes and no questions about absent objects, drawn at random, among frequent objects, or among co-occurring ones. Sclar et al. [35] show that meaning-preserving changes of prompt format move accuracy by up to 76 points. This study transfers the probes of POPE and tests paraphrases on the artifacts of a static state (§ 4.5).

Table 1 summarizes the position of this study and of S1Mal among the closest works.

WorkEvidenceOutput readCalibrationFixed FPRTime split
Chawla and Prasad [6]Ghidra pseudo-CJSON verdict××newer test set
PE2Prompt [37]EMBER featuresforced label×n.r.n.r.
MARS [8]evidence bundleJSON verdict, rule-scored claims×××
Kurlandski et al. [17]bytes, assembly, pseudo-Ctrained language modeln.r.n.r.✓
AsmRAG [15]Ghidra assemblynearest-neighbor voten.r.per function✓
SecJev [7]traffic, logs, telemetrytyped probability✓n.r.transfer
S1Mal (ours)digest, Ghidra cardstyped answers and embedding of CLM-8B✓✓✓, OOD

Table 1. Comparison with the state of the art.

Proposed Methodology

The pipeline measures how well typed-output decision models detect Windows Portable Executable (PE) malware from ×: not done; n.r.: not reported.

static evidence, through three readouts of their answers and embeddings, and fuses two readouts of CLM-8B into S1Mal. Every file crosses five modules, which group the seven numbered stages of Figure 1:

  • Data and splits (stage 1). Three corpora are deduplicated by code and split by first-seen date (malware) or by software component (benign files).

  • Isolated static analysis (stage 2). A virtual machine without network parses each binary, decompiles it with Ghidra, matches capa rules and exports text and numbers only.

  • State construction (stage 3). The host renders the records into a canonical textual state: a digest (S0), decompiled function cards (S1), or the digest plus the cards (S2).

  • Typed questioning (stages 4 and 5). A System One model reads the state and answers typed questions: one verdict, or 32 atomic behaviors.

  • Readout and decision (stages 6 and 7). The answers or the model’s embedding become a malware score (readouts A0, A1 and A2), and S1Mal fuses the atomic answers and the embedding of CLM-8B; each score is calibrated and compared with a threshold set at 1% false positive rate (FPR).

Algorithm 1 gives the procedure for one file, where ℓ⃗\vec{\ell} collects the logits ℓq\ell_q and a question that exceeds the window leaves its logit at 0. Each module is described below, in the order in which a file crosses them.

Data and Splits

Malware comes from BODMAS [43] and SOREL-20M [12], benign files from a local collection acquired in a clean virtual machine (VM). BODMAS holds 57,293 disarmed Windows malware files first seen between August 2019 and September 2020. SOREL-20M contributes 46,918 disarmed files

Algorithm 1: Decision for one file.

Input: PE file xx; model MM with embedding EME_M and window WMW_M; verdict question qvq_v; questions QQ; readout rr with combiner grg_r, calibration map crc_r, threshold τ1%\tau_{1\%} and abstention band (τlo,τhi)(\tau_{\mathrm{lo}}, \tau_{\mathrm{hi}}); head hh (A2) or mean ℓˉ\bar{\ell} of five folds (S1Mal)

Output: decision y^\hat{y}, probability p^\hat{p} and deferral flag dd, or a status

  1. R←STATICANALYSIS⁡(x)R \leftarrow\operatorname{STATICANALYSIS}(x); // isolated VM

  2. if a state block lacks its tool record then

  3.     return missing_blockmissing\_block

  4. s←RENDERSTATE⁡(R)s \leftarrow\operatorname{RENDERSTATE}(R); // S0 or S2, canonical

  5. if ∣s⊕q∣>WM|s \oplus q| > W_M for every q∈Qq \in Q then

  6.     return over_limitover\_limit

  7. if r=A2r = \mathrm{A2} then

  8.     z←h(EM(s⊕qv))z \leftarrow h(E_M(s \oplus q_v)); // embedding, trained head

  9. else

  10.     for each q∈Qq \in Q do

  11.         ℓq←logit⁡M(true⁡∣s,q)\ell_q \leftarrow\operatorname{logit}_M(\operatorname{true}\mid s,q)

  12.         if r=S1Malr = \mathrm{S1Mal} then

  13.             z←gr(ℓˉ,h(EM(s⊕qv)))z \leftarrow g_r(\bar{\ell}, h(E_M(s \oplus q_v))); // answers + head

  14.         else

  15.             z←gr(ℓˉ)z \leftarrow g_r(\bar{\ell}); // A1: trees; A0: identity

  16. p^←cr(z)\hat{p} \leftarrow c_r(z); y^←1[z≥τ1%]\hat{y} \leftarrow1[z \ge\tau_{1\%}]; d←1[τlo<z<τhi]d \leftarrow1[\tau_{\mathrm{lo}} < z < \tau_{\mathrm{hi}}];

  17. return (y^,p^,d)(\hat{y},\hat{p},d)

first seen between January and May 2017 and serves only as out-of-distribution (OOD) data. The benign collection holds 198,461 PE files from MSYS2, Cygwin, winget packages, a Windows 10 x86 installation image and the payloads of existing installers, with the provenance of each file recorded.

To build our test environment we use the following approach:

Deduplication. Files are grouped into code species by the hash of their executable sections, and one file per species survives. This removes 79.8% of BODMAS, leaving 11,562 files, and keeps near-copies from crossing splits, a redundancy shown to inflate the behavior tagging of a byte-level model by up to 35.6 points on a corpus that includes SOREL20M [17].

Splits. Malware is split by first-seen date, following the temporal constraints of TESSERACT [31]. T0T_0 (up to October 2019) fits every trained component, V (November and December 2019) tunes and calibrates, and TEST (January to September 2020) measures. Benign files are split by software component into BfitB_{\mathrm{fit}}, BvalB_{\mathrm{val}} and BtestB_{\mathrm{test}}, so that the versions of one program never straddle two splits.

Core set. The primary population keeps native-code executables and libraries. .NET, Visual Basic, AutoIt and installer files form a separate stratum scored by true positive rate (TPR) only. Benign files are matched to the bitness and file kind of the development malware, so that neither property separates the classes.

Isolated Static Analysis

The binaries never leave the analysis host, a laptop with an Intel Core i9-13900H, an Nvidia RTX 4060 Laptop and 64 GiB of RAM, where a REMnux VM without a network adapter runs the static analysis; no sample is ever executed (Figure 2). Inside the VM, pefile 2024.8.26 [5], Detect It Easy 3.21 [13] and FLOSS 3.1.1 [23] extract headers, sections, imports, packing and strings, Ghidra 12.1.4 [27] decompiles the functions, and capa 9.4.0 [24] matches its rules on Ghidra’s program, with the MITRE ATT&CK and Malware Behavior Catalog (MBC) identifiers of each capability.

Figure 2. From the binary to the textual state.

Only text and numbers leave the VM: the host checks the records, replaces any embedded executable header or encoded blob with a placeholder, and stores them as Parquet tables from which it builds the states. The workstation that runs the models (§ 3.6) receives these tables and states only.

Textual States

A System One model reads text, so each file becomes a state: a plain-text description of what the static tools found in it. The state is built deterministically from the tool records, one fact per line. Numbers become named classes (e.g., a size or an entropy class), whose edges are fitted on the training files only, and any text taken from the file is quoted and escaped.

Shortcut control. The malware and benign collections differ in ways that say nothing about behavior. In a pilot, the year of the compilation timestamp alone separated the two classes with an AUROC of 0.83, and the name of the toolchain with 0.78-0.80. A state therefore carries no antivirus output, hash, file name, Machine or Subsystem field, timestamp or tool banner. The remaining collection-specific details are rewritten in the same way for both classes: library names other than the Windows system DLLs and standard section names become neutral labels, years and build paths become placeholders, and words that reveal the compiler or the bitness are removed. A file whose tool record is missing gets no state, so that a tool failure never reads as “nothing found”.

S0, the digest. The digest summarizes a file in seven blocks and at most 1,024 tokens (Table 2): the file, its sections, packing, imports, capabilities, strings and code. Imports are grouped by the behavior they enable, through the 685 sensitive APIs named by capa’s rules, in 11 categories from process injection to anti-analysis. Capabilities come rarest first, ranked by their frequency among benign training files. A digest over budget is shortened in a fixed order. The median digest is 610 tokens long.

BlockContentCap
B1 Filekind, size class, overlay, resources, TLS callbacks, signature60
B2 Sectionscount, entry section, roles or quoted names, size, ratio and entropy classes, write and execute flags180
B3 PackingDetect It Easy findings, packed flags of detector and heuristic40
B4 ImportsDLL count, ordinal class, sensitive APIs by category, system DLLs350
B5 Capabilitiescapa rules with ATT&CK and MBC identifiers, rarest first300
B6 Stringscounts per category and up to 40 quoted strings300
B7 Codefunction count class, share of functions calling sensitive APIs40

Table 2. Blocks of the S0 digest.

S1, the decompiled function cards. S1 renders up to 16 decompiled functions as cards, without the digest. Each function becomes a card: a class of the number of its caller, the functions and APIs it calls, the strings it uses, and its pseudo-C from Ghidra. The pseudo-C is normalized: function and variable names become numbered placeholders, long constants and addresses become generic tokens, and comments are removed. The 16 functions are chosen by alternating three rankings: the functions where capa found a capability, rarest first; the functions that call the most sensitive APIs or hold notable strings; and the functions closest to the entry points. S1 measures what the decompiled code carries without the facts of the digest, and together with other selections, fewer cards and smaller budgets it enters the state ablation of E2 (§ 4.3).

S2, the digest with function cards. S2 joins the digest and the cards of S1, within 7,680 tokens: the 8,192-token window of CLM-8B and the LLMs, minus the question and a margin. The median S2 state is 6,660 tokens long.

Planted text. Strings come from the file, so an attacker controls them. The builder normalizes their characters, removes control characters and chat-template markers, and flags text addressed to an analyst, e.g., “this file is safe”, while keeping it in the state. The build stops if a long hex run or a special token of a model survives.

Primary state. A rule fixed before the experiments chose the state of CLM-8B and the LLMs: S2 replaces S0 only if it raises the validation AUROC of the heads of CLM-8B (§ 3.7) with a 95% paired interval above zero. On 782 validation files, S2 reached an AUROC of 0.9954 against 0.9919 for S0, a gain of 0.0036 [0.0002, 0.0085], so S2 is their primary state. The open models and DET read S0.

Typed Questions

A typed question pairs a text with an answer type and a criterion for each answer. Boolean questions accept true or false, choice questions list options, and score questions list ordered levels. Every question has ten paraphrases.

Two sets of questions are used. The verdict questions ask whether the program described by the state is malware, in four forms: the question itself, its benign counterpart, a five-level score and a two-option choice in both orders. The atomic questions ask about 32 behaviors (Appendix § 7): 28 malicious behaviors, from process injection and persistence to ransomware encryption and self-propagation, and 4 benign indicators (e.g., a graphical application or a runtime library). Each behavior is phrased in three vocabularies: plain language, MITRE ATT&CK and capa. The plain process-injection question reads: “Based only on the evidence in the state (IMPORTS and CAPABILITIES), does this program write code into another running process and make that process run it?” Its true criterion reads: “Remote-process memory and thread APIs (opening a process, allocating or writing remote memory, creating a remote thread), or injection capabilities, appear in the state.” A category question and twelve questions about single functions serve the ablations of E3 and E2 (§ 4.3).

Each model receives the same question through its native interface. CLM-8B encodes the state, a blank line and the question, and embeds each candidate answer through its criterion. The open models receive state and question as fields of a typed decision request. The generative baselines read a fixed chat template whose system prompt declares the state untrusted data, then the state inside <state> tags, the question, and the instruction to reply with one word, Yes or No.

System One Models

Table 3 lists the models and Figure 3 shows how they are read.

Figure 3. From the state and the typed question to the decision.

CLM-8B. CLM-8B [18] is a contrastive dual encoder. Let EE be the last-token embedding of a frozen Qwen3-8B [42] (36 layers, 4,096 dimensions), and fSf_S, fAf_A the state and action heads: three linear layers each, from 4,096 to 1,536, 1,536 and 512 dimensions with GELU and layer normalization, followed by L2 normalization (18.9 million parameters in total). For state ss, question qq and candidate answers a∈Aqa \in\mathcal{A}_q, each with a text cac_a (the answer followed by its criterion for a boolean question, the option or the level otherwise),

P(a∣s,q)=exp⁡(λcos⁡(fS(E(s⊕q)),fA(E(ca))))∑a′∈Aqexp⁡(λcos⁡(fS(E(s⊕q)),fA(E(ca′))))(1)P(a \mid s,q) = \frac{\exp\left(\lambda\cos(f_S(E(s\oplus q)),f_A(E(c_a)))\right)}{\sum_{a'\in\mathcal{A}_q}\exp\left(\lambda\cos(f_S(E(s\oplus q)),f_A(E(c_{a'})))\right)} \tag*{(1)}

where ⊕\oplus joins the texts with a blank line and λ\lambda is the learned inverse temperature of the contrastive loss, clamped at 100, the value it reaches in the released heads. The released heads give the verdict and atomic readouts, and the embedding E(s⊕q)E(s\oplus q) feeds the trained heads of A2. Since EE is causal and pooled on the last token, the key-value cache of the state is the same for every question asked about it: the pipeline encodes each state once and then only the tokens of each question. On 13,500 development answers this changed the answer probability by 0.003 on average and the decision at 0.5 in 0.35% of the answers, a bound that also includes a change of GPU, and it cuts the encoding cost of the 33 atomic questions by an order of magnitude.

Open decision models. Ten open models, chosen from the releases of September and October 2026, cover the architectures of the class: pointer heads on small Qwen3.5 decoders adapted with LoRA (Kev-0.8B [29], Strands Decider 2B [36]), fully fine-tuned Qwen3.5 decoders (decider [26]), encoders that score option markers (Von [30], Laya [22]) and LFM2.5 models (Liquid d1²). In E1 they read S0 through a typed decision API, at temperature 1.0.

LLMs read through logits. Two generative large language models (LLMs) answer the same questions through their next-token distribution: Qwen3-8B, which shares the weights file of the CLM-8B encoder, and Foundation-Sec-1.1-8B-Instruct, a later release of the security-specialized Llama 3.1 model of [40]. One forward pass at temperature 0, with thinking disabled, gives P(true)=∑p(Yes)/(∑p(Yes)+∑p(No))P(\mathrm{true}) = \sum p(\mathrm{Yes})/(\sum p(\mathrm{Yes})+\sum p(\mathrm{No})) over the case and spacing variants of both words. The pair separates the effect of the readout from that of the backbone.

Compute Platform and Isolation

The models run on a workstation equipped with an AMD Ryzen 9 9950X3D CPU, an NVIDIA GeForce RTX 5090, and an RTX 4090 GPUs, and 192 GB of RAM, with driver 615.78.08 and CUDA 13.4. llama.cpp [10] build b11429 serves CLM-8B, the two LLMs and Qwen3-Embedding8B [45] in bf16 with 8,192-token windows; the open models use their own runtimes, and the Liquid d1 models llama.cpp build b11535. Each server listens only on the loopback interface, one model occupies one GPU with all its layers, and a request, state and question together, longer than a model’s window is marked over limit instead of being cut; an atomic question left unanswered in this way enters the combiner at P=0.5P = 0.5.

The workstation never receives a binary. Work arrives from the analysis host as packages of text and numbers, which a checker scans for executable headers, archives and encoded payloads, on both machines. The workstation accepts only a fixed set of commands, reaches only the model and package registries, and stops every job if a loader for PE files appears.

Readouts and Decision

Three readouts turn the answers or the embedding of a model into a malware score zz, and S1Mal fuses two of them for CLM-8B.

A0, verdict. The score is the logit of P(true)P(\text{true}) for the verdict question.

A1, atomic. The answers to the 32 atomic questions in plain language give logits, with probabilities clipped to [0.005,0.995][0.005,0.995], and one-hot flags of the file’s format route are added. A shallow gradient-boosted tree combiner (LightGBM, depth 3, seven leaves, 200 trees, learning rate 0.05, balanced class weights) is fitted on T0 and BfitB_{\mathrm{fit}}. An L2-regularized logistic regression with balanced class weights, whose strength is chosen among ten values from 0.001 to 100 by balanced log-loss on V and BvalB_{\mathrm{val}}, and a symbolic noisy-OR without training are the alternatives compared on development files, where the trees were selected for every A1 arm before the freeze. The noisy-OR scores z=Smal(1−αSben)z = S_{\mathrm{mal}}(1-\alpha S_{\mathrm{ben}}) with α=1\alpha= 1, where Smal=1−∏q(1−pq)S_{\mathrm{mal}} = 1-\prod_q(1-p_q) runs over the malicious behaviors and SbenS_{\mathrm{ben}} is the noisy-OR of the four benign indicators.

A2, embedding. The CLM-8B embedding of the state and the verdict question feeds state and action heads initialized from the released ones and trained with cross-entropy over the two answers, with balanced class weights, on T0 and BfitB_{\mathrm{fit}}. Training uses AdamW with a one-cycle cosine schedule over a budget of at least 1,500 optimizer steps, which early stopping on V and BvalB_{\mathrm{val}} ends earlier for five seeds. One of eight settings of learning rate, batch size and weight decay is chosen on seed 0 by the validation loss, and five seeds are then trained with it. A convergence check per seed is reported. Logistic and two-layer probes on the raw embedding (A2-ctrl), and the same probes on Qwen3-Embedding-8B, measure what the heads add.

S1Mal, fusion. S1Mal joins A1 and A2 of CLM-8B in three steps (Algorithm 1):

  1. Head score. Heads trained as those of A2 give the logit of the malware probability of the state, computed out of fold on T0 and BfitB_{\mathrm{fit}} as in stacked generalization [41], so that the trees never see the score of heads trained on the same file: the files are cut into five folds stratified by class, heads trained on four folds score the fifth, and every other file receives the mean hˉ\bar{h} of the logits of the five fold heads, each temperature-scaled on V and BvalB_{\mathrm{val}}; the fold heads start from the released heads and use the setting, seed and early stopping of A2.

  1. Trees. Gradient-boosted trees in the configuration of A1, fitted anew on T0 and BfitB_{\mathrm{fit}}, weigh the 32 atomic logits and the route flags together with this logit.

  1. Decision. The score is calibrated and compared with its own τ1%\tau_{1\%}, as for every readout (below).

We built S1Mal on CLM-8B because of its context window and of the measured reliability of its typed answers. Its 8,192-token window takes the decompiled function cards of S2, on which the atomic answers that explain each decision can draw: the open models read the digest S0 (§ 3.3), and the 1,024- or 4,096-token context of some of them (Table 3) cannot take the 7,680 tokens of S2. On S2, the state that S1Mal reads, E7 probes the typed answers of CLM-8B for fabrication and invariance (§ 4.5), so the answers that S1Mal shows the analyst have a measured reliability.

ModelSizeArchitectureWindow (tok.)
Kev-0.8B [29]0.8BQwen3.5, LoRA, pointer head8,192
decider-0.8b [26]0.8BQwen3.5, fully fine-tune8,192
decider-2b2BQwen3.5, full fine-tune, RL, merged LoRA8,192
decider-4b (Q4_K_M)4BQwen3.5, full fine-tune, merged LoRA8,192
Strands Decider [36]2BQwen3.5, LoRA, pointer head4,096
Von [30]395MModernBERT-large encoder8,192
Laya multilingual [22]322MmmBERT-base encoder1,024
Laya typed decisions421MModernBERT-large encoder1,024
d1-3B²3.1BLFM2.58,192
d1-omni-600M587MLFM2.58,192
CLM-8B [18]8.2Bfrozen Qwen3-8B, contrastive heads8,192

Table 3. Decision models.

Calibration and operating point. A Platt map [32] with balanced class weights is fitted on the score zz of every arm on V and BvalB_{\mathrm{val}}; the A2 heads are first temperature-scaled [11], and E4 compares this map with isotonic and temperature maps. The operating point τ1%\tau_{1\%} is the smallest threshold whose FPR on BvalB_{\mathrm{val}} is at most 1%, and a file is called malware when z≥τ1%z \geq\tau_{1\%}. On the 2,785 benign validation files with a state, τ1%\tau_{1\%} rests on 27 false positives. An abstention band (τlo,τhi)(\tau_{\mathrm{lo}},\tau_{\mathrm{hi}}) on the score, whose two thresholds are chosen together on the validation files to maximize coverage at a class-balanced selective risk of 1%, flags as deferred the files whose score falls inside it; the decisions at τ1%\tau_{1\%} include them.

Evaluation and Results

Experimental Setup

Table 4 lists the experiments and their primary endpoints. An arm is one model with one readout on one input: CLM-8B with A0, A1 and A2 on S2, and S1Mal, which fuses its A1 and A2; every open model with A0 and A1 on S0, and with A2 on S0 in E1b; the two LLMs with A0 and A1 on S2; DET on the digest facts; and the Qwen3-Embedding probe on S2. Combiners, heads and probes are fitted on T0 and BfitB_{\mathrm{fit}}, tuned and calibrated on V and BvalB_{\mathrm{val}}, and measured on TEST and BtestB_{\mathrm{test}}. SOREL-20M measures transfer to another source and period.

Protocol. Each experiment fixed its hypotheses, endpoints and comparisons before its runs, and every choice on development files; it was then frozen, and only its frozen thresholds, calibration maps, combiners and heads scored TEST, BtestB_{\mathrm{test}} and the OOD set, in a single pass. S1Mal joined E1 after this freeze, with its design fixed on the same development files and its own single test pass.

Metrics. AUROC comes with 95% cluster-bootstrap intervals over 2,000 resamples, where clusters are malware families and benign software groups. The standardized partial AUROC covers FPR up to 1%. The TPR at τ1%\tau_{1\%} is reported with the realized FPR on BtestB_{\mathrm{test}} and Clopper-Pearson intervals, since a threshold fixed on validation data is what a deployment uses [28]. Precision, F1 and the Matthews correlation are reported at prevalences of 50%, 10% and 1%, because precision depends on the base rate [2]. Calibration is measured by the expected calibration error (ECE, 15 bins) and the negative log-likelihood [11], and by the Brier score, at a prior of 0.5, and selective prediction by the area under the risk-coverage curve and the coverage at 1% risk. Paired comparisons use exact McNemar tests on decisions and a paired bootstrap of AUROC differences, with Holm correction within each family at α=0.05\alpha= 0.05 and one primary endpoint per claim.

Baselines. DET applies a logistic combiner to the structured facts of the digest, so it measures what the facts give without a language model. Qwen3-8B and Foundation-Sec8B, read through the probabilities of their answer tokens, and a logistic probe on the Qwen3-Embedding-8B vector of the state measure what general-purpose language models obtain from the same state. Every arm gets its threshold τ1%\tau_{1\%} on BvalB_{\mathrm{val}}.

Design fixed on development data. The primary state (§ 3.3), the 32 atomic questions and the gradient-boosted combiner of A1 (§ 3.7) were fixed on development files before the freeze; E1 and experiment adopts them, while E2 and E3 vary them with a logistic combiner for their A1.

Detection Performance

Table 5 reports E1 on the test split, TEST and BtestB_{\mathrm{test}}: 4,703 malware and 6,126 benign files with a state; the other 1,001 files (971 benign), whose state lacks a tool record, keep an explicit status and no score (§ 3.3).

Typed readouts. Figure 4 and Table 9 (Appendix § 8) give the readouts of every model that reads a prompt. A single zero-shot verdict (A0) reaches at most 0.8590 AUROC: it compresses the whole state into the probability of one answer, a judgment that these general-purpose decision models never learned on static evidence. The 32 atomic questions of A1 split the same decision into behaviors that the models recognize in the text (e.g., persistence, process injection or packing), and a gradient-boosted combiner weighs the answers: A1 lifts every one of the 13 models, up to 0.9834 AUROC, and all 11 lifts that the protocol tests hold after Holm correction. For CLM-8B the lift is +0.2569 (95% CI [+0.1790, +0.3365]), and the heads trained on its embedding (A2) reach 0.9943 [0.991, 0.997], +0.2749 over A0. A logistic probe on the same embedding (A2-ctrl) ranks the files slightly better than the heads (E1-C1: -0.0013, Holm p=0.007p = 0.007): the decision is linearly readable from the state embedding of CLM-8B.

Figure 4. Readouts of every prompt-reading model.

Evidence and backbone. A2 adds +0.0041 AUROC ([+0.0012, +0.0078]), Holm p=0.010p = 0.010 over DET, a logistic combiner on the digest facts without a language model: CLM-8B reads the function cards of S2 and the wording of imports and strings. With the same Qwen3-8B backbone, its trained heads add +0.0449 over the answer-token probabilities of Qwen3-8B with A1, and +0.0108 over the best open decision model with A1, decider-4b (GGUF Q4_K_M).

S1Mal: atomic answers and embedding fused. S1Mal joins the two readouts of CLM-8B: trees in the configuration of A1 weigh the 32 atomic answers together with the cross-fitted score of heads trained as those of A2. On the test split S1Mal reaches an AUROC of 0.9946 [0.991, 0.997], +0.0184 over A1 (Holm pp = 0.002): the embedding score carries the evidence that the 32 questions leave unasked, and the ranking matches that of A2 (Holm pp = 0.370). The fusion acts on the decisions: at τ1%\tau_{1\%} S1Mal detects 93.47% of the malware, +2.57 points more than A2 (McNemar pp < 0.001), at a realized FPR of 1.45% against 1.11%; at the same FPR A2 reaches 92.15%, so the fused ranking and the operating point each bring about half of the gain. Every score of S1Mal keeps the 32 atomic answers among its inputs, so each decision comes with the behaviors that CLM-8B recognized in the state.

Heads on the open models. E1b trains the heads of A2 on the embedding of each open decision model, the final hidden state at the last token of its own verdict prompt over S0, with seed 0 as the primary variant. A2 lifts each of the 9 models whose runtime exposes this representation over its A1, and all 9 lifts hold after Holm correction; the best, Strands Decider 2B, reaches an AUROC of 0.9948, and 6 of the open models match the A2 of CLM-8B after Holm correction (Figure 4). The decision is present in the representation of models from 322M to 4B parameters, and heads on the

embedding recover what the verdict and the atomic answers leave unused.

Low false-positive rates. Figure 5 shows the region that a deployment uses. The thresholds, fixed on BvalB_{\mathrm{val}}, carry over to the unseen benign files of BtestB_{\mathrm{test}} with a realized FPR from 0.95% to 1.91% across the arms of Table 5. At 0.1% FPR, the six benign test files that this rate allows, S1Mal keeps 59.15% of the malware, the most in Table 5, whose arms keep at most 46.59%: the benign files that the embedding scores highest set this tail, and the atomic answers that S1Mal adds plausibly tell them apart from malware. A threshold at that rate needs the larger benign validation set discussed in § 4.7.

Figure 5. Detection at low false-positive rates.

ArmInputAUROC [95% CI]pAUC1%_{1\%}TPR at τ1%\tau_{1\%}FPRECE
DETS0 facts0.9901 [0.985, 0.994]0.828488.24%1.91%0.0139
Qwen3-Embedding probeS20.9956 [0.993, 0.997]0.867893.62%1.42%0.0066
Qwen3-8B logits, A1S20.9493 [0.929, 0.964]0.601336.30%0.95%0.0235
Foundation-Sec-8B logits, A1S20.9733 [0.962, 0.981]0.659564.19%1.58%0.0184
decider-4b (GGUF Q4_K_M), A1S00.9834 [0.975, 0.989]0.753075.44%1.29%0.0167
CLM-8B A2-ctrl probeS20.9955 [0.993, 0.997]0.897492.94%1.11%0.0104
CLM-8B A0S20.7194 [0.643, 0.796]0.52588.82%1.16%0.1024
CLM-8B A1S20.9763 [0.965, 0.985]0.671357.90%1.19%0.0161
CLM-8B A2S20.9943 [0.991, 0.997]0.876090.90%1.11%0.0060
S1Mal (CLM-8B, ours)S20.9946 [0.991, 0.997]0.885193.47%1.45%0.0078

Table 5. Detection on the test split (E1).

Shortcut controls. The raw state, without canonicalization, raises the AUROC of A2 by +0.0012 (Holm pp = 0.045). The library names, section names, build paths and toolchain words that canonicalization rewrites carry a small signal that the embedding of CLM-8B picks up, about a thousandth of AUROC, and the canonical state gives it up on purpose: these properties differ between the two collections for reasons unrelated to behavior, so a detector that relied on them would learn the collections.

State and Question Design

E3 and E2 test the design choices of § 3.

Questions. Across the 13 models that read a prompt, the 32 atomic questions with a trained combiner rank the files above the single zero-shot verdict for 12 models, with gains up to +0.5082 AUROC; for CLM-8B the gain is +0.2378, and Laya multilingual 322M is the exception. A better combiner adds to this gain: shallow gradient-boosted trees improve on a logistic combiner of the same answers for 8 of the 13 models, while an untrained noisy-OR over the behaviors falls below the logistic combiner for all 13: the evidence lies in how the answers combine, which a rule over independent behaviors cannot weigh. The number of questions counts. The single most informative question ranks the files below the full set for 10 of the 13 models, and the gap closes as questions are added, with 4 models still below the full set at 16 questions. Terminological choices carry minimal weight: the MITRE ATT&CK and capa vocabularies match plain analyst language in all but 2 of 39 comparisons, and asking each behavior in both polarities changes 2 of 26. On these files the digest facts read by DET (AUROC 0.9776) rank above the atomic answers of 12 of the 13 models; the embedding readouts pass DET on the test split (Table 5), and the atomic answers name the behaviors behind each decision. With every question design of CLM-8B, S1Mal adds the A2 score to the answers of that design and ranks the files above the answers alone for 5 of the 6 designs after Holm correction, and level with A2 for all of them.

State. For CLM-8B, S2 and the cards alone (S1) each rank the files +0.0106 AUROC above the digest S0 with A2, on their own paired files, a difference that does not hold after Holm correction; the number of cards, the token budget and the selection policy leave A2 unchanged (0 of 11 comparisons). The decision of the embedding rests on redundant evidence: removing any one block of S0 keeps its AUROC within the interval, and each of the Sections, Imports, Capabilities and Strings blocks alone keeps nearly all of it, with a loss of at most +0.0167, while the File, Packing and Code blocks alone lose +0.1175 to +0.2433. The typed answers depend more on the state than the embedding does: a budget of 7,680 tokens lifts A1 by +0.0461 over 2,048 tokens, and the attacker-controlled fields that S0 leaves out lift A0 and A1 by +0.0970 and +0.0547, the shortcut that the protocol expected, while A2 stays unchanged. On these files DET ranks above A2 on S0 (-0.0252). Across the 30 levels of the state, S1Mal ranks the files above A1 for 26: the fusion keeps the decision of the embedding wherever the state changes.

Calibration, Stability and Deployment

Table 6 and Figure 6 report E4 on the test split, where each arm takes the map, among Platt, isotonic and temperature scaling, with the lowest out-of-fold log-loss on V and Bval_{\mathrm{val}}, fitted there and frozen. Recalibration turns the zero-shot verdict into a usable probability: CLM-8B A0 has an ECE of 0.3691 at the class prior, and its isotonic map brings it to 0.0479, an improvement of 0.3212. The primary endpoint holds for all 7 arms: the frozen map of each one lowers its ECE, and all 7 improvements hold after Holm correction (Holm p≤0.018p \leq0.018). The trained readouts arrive calibrated: A2 starts at 0.0124 and ends at 0.0060 after Platt scaling, below DET (0.0139). Recalibration repairs the probability scale, while the ranking quality decides how much abstention buys. With an abstention band fitted for a 1% selective risk, A2 decides 92.36% of the test files at a realized risk of 1.32%, against 74.81% for DET, and for both the realized risk stays between 1.32% and 1.49%. S1Mal moves from an ECE of 0.0129 to 0.0078 with its Platt map, an improvement of 0.0051 (bootstrap p=0.018p = 0.018), and its band decides 93.98% of the test files, more than A2, at a realized risk of 1.56%. The risk-coverage curves of Figure 6 rank the files by their distance from the calibrated operating point, the confidence function is fixed before the test. This distance counts a miss scored far on the benign side as a confident decision, so on the test files the curves of A2 and DET take in their misses early and climb to a few percent, up to 4.58% for A2, while the band, whose two thresholds are fitted together on valiation, defers the files around the threshold and holds the realized risk reported above. The A0 verdicts decide at most 16.01% of the files, at a realized risk of 3.10%, and 3 of the 5 reach no band at that risk. We can assume that a calibrated verdict still overlaps across the classes, and the atomic and embedding readouts are what separate them.

Figure 6. Calibration and selective prediction.

ArmECEMapBrierBand at 1% risk
rawrecal.CoverageRisk
CLM-8B A00.36910.0479isotonic0.20600 (infeasible)-
Qwen3-8B logits, A00.30250.0164isotonic0.18330 (infeasible)-
Foundation-Sec-8B logits, A00.15420.0316Platt0.153716.01%3.10%
decider-2b A00.16200.0642isotonic0.21414.60%3.63%
Kev-0.8B A00.10840.0719isotonic0.21940 (infeasible)-
DET0.01840.0139Platt0.031074.81%1.49%
CLM-8B A20.01240.0060Platt0.026292.36%1.32%

Table 6. Calibration and abstention (test split, E4).

Stability. Inference is deterministic: on 1,831 files, new server sessions with cold and cached requests give the same probability for every file with A0 and A2 (0.00% decision flips), and every configuration of E5 repeats its decisions across its passes. The variation comes from training. Across 5 seeds the AUROC of A2 has a standard deviation of 0.0002 (Table 10, Appendix § 8), and S1Mal, with its cross-fitted heads trained again under each seed, keeps an AUROC between 0.9938 and 0.9946, with 1.64% of the test files changing decision between two seeds (1.26% for A2). When E6 trains the heads again at the setting of its own validation grid, early stopping halts 2 of its 5 seeds after 4 epochs: these heads detect 50.10% and 60.75% of the test malware at τ1%\tau_{1\%}, against 88.75% to 90.73% for the others, and drive the disagreement between seeds (10.55% on average), so the validation AUROC of every seed flags them before deployment. The logistic probe on the same embedding (A2-ctrl) changes 0.01% of its decisions between seeds, at the AUROC of the heads. Sampling at temperature 1 changes 1.88% of the decisions of Qwen3-8B and 15.16% of those of Foundation-Sec-8B, a variation that a typed probability read in one forward pass does not have.

ArmAUROCTPR at τ1%\tau_{1\%}pAUC1%_{1\%}
seed 0mean ± sdseed 0mean ± sdseed 0mean ± sd
Qwen3-Embedding-8B probe0.99560.9956 ± 0.000093.62%93.62 ± 0.00%0.86780.8678 ± 0.0000
CLM-8B A2-ctrl, logistic0.99550.9955 ± 0.000092.94%92.94 ± 0.00%0.89740.8974 ± 0.0000
CLM-8B A2-ctrl, two-layer0.99460.9946 ± 0.000690.88%91.25 ± 0.66%0.89740.8950 ± 0.0189
CLM-8B A2, cold start0.99480.9942 ± 0.000991.07%89.92 ± 2.13%0.91600.8924 ± 0.0201
CLM-8B A2, multi-task0.99320.9928 ± 0.001590.71%89.07 ± 3.01%0.86790.8626 ± 0.0209
CLM-8B A2, raw state0.99550.9952 ± 0.000491.28%90.92 ± 1.38%0.91300.9087 ± 0.0072
CLM-8B A20.99430.9941 ± 0.000290.90%90.16 ± 0.54%0.87600.8752 ± 0.0039

Table 10. Seed 0 and the mean over the seeds (test split).

Deployment on a laptop GPU. E5 runs the frozen System One on the laptop GPU of the analysis host and compares it with the workstation on 1,013 files of the test split, read as S0 (Table 7). The bf16 model with its 8,192-token window does not fit in 8 GB, so the laptop runs CLM-8B as a 5-bit GGUF at 2,048 tokens: the deployed configuration decodes a file in 0.359 s with 8.08 mWh, and the workstation runs the bf16 model 3.14 times faster. S1Mal adds the 32 atomic questions after the same encoder pass and decides a file in 1.013 s with 21.85 mWh, 0.580 s of which go to the atomic answers that name the behaviors behind each decision. The two serving paths of the laptop give the same decision on all 1,013 files, the primary endpoint of E5. The 5-bit weights keep the ranking, with an AUROC of 0.9827 against 0.9922 in bf16, and move the scores toward benign around the frozen threshold: the TPR at τ1%\tau_{1\%} goes from 90.33% to 52.19% and the FPR from 1.94% to 0.22%. The precision of the weights moves the decisions about twice as much as the device does (16.88% against 8.69%), so each deployment tier fits its own threshold on VV and BvalB_{\mathrm{val}}, with the heads unchanged.

MachineWeightsAUROCTPR at τ1%\tau_{1\%}FPRLatency [s]Files/sEnergy [mWh]
Workstationbf160.992290.33%1.94%0.1148.349.26
WorkstationQ5_K_M0.985960.40%0.43%0.1128.548.77
LaptopQ6_K0.985950.55%0.43%0.3782.538.55
LaptopQ4_K_M0.978853.28%0.86%0.3492.757.82
LaptopQ5_K_M0.982752.19%0.22%0.3592.688.08

Table 7. Deployment configurations of CLM-8B (E5). Workstation: AMD Ryzen 9 9950X3D, NVIDIA GeForce RTX 5090, 192 GB of RAM. Laptop: Intel Core i9-13900H, NVIDIA GeForce RTX 4060 Laptop GPU, 64 GB of RAM.

Figure 7 places the other models of the laptop on the same axes. Qwen3 base models of 0.6B, 1.7B and 4B parameters, with heads trained from a cold start on their embeddings of the same S0, reach an AUROC of 0.9881, 0.9879 and 0.9949 in 0.068 to 0.205 s per file, with 5.6 GiB for the largest. The 10 open decision models answer their verdict in 0.020 to 0.265 s with 1.6 to 6.7 GiB, at an AUROC of 0.4239 to 0.7072. On this subsample the 4B encoder with heads ranks the files at least as well as the full System One (AUROC 0.9949 against 0.9922) in 0.205 s per file: trained heads carry the decision onto edge hardware, the setting that the open decision models target.

Figure 7. Accuracy and inference time on a laptop GPU.

Hallucination and Robustness

E7 adapts the existence probes of POPE [20] to static artifacts: the models are asked about APIs, strings and capabilities absent from the state, drawn at random, among the most frequent ones, or among those that co-occur with the present ones. A second sub-sample tests the invariance of the decisions to polarity, option order, paraphrase [35], padding and repetition. E8 plants instructions and legitimacy claims in the strings of synthetic states, the attack that ALIBI showed on generative verdicts [9], with and without the sanitizer.

Fabrication. Each probe asks whether the state contains one item, and a yes on an absent item is a fabrication. Figure 8 reports the fabrication rate of the 10 models on the test probes in each regime: from 0.00% to 16.52% on random items, from 0.12% to 19.07% on popular items and from 0.00% to 19.81% on adversarial ones. CLM-8B fabricates 10.63% of the random items ([9.23%, 12.03%]), 1.29% of the popular and 1.10% of the adversarial ones, and confirms 94.54% of the present imports, strings and capabilities. Its fabrications gather on random import names (17.15%), and it never affirms an absent capability (0.00%): the frequent and co-occurring items, which a generative model tends to presume [20], are where its typed answers hold best, so the atomic questions about behaviors rest on the part of the state that CLM-8B reads most reliably.

Figure 8. Fabrication on absent artifacts.

Invariance. On a label-balanced sub-sample of 1,000 test files, 916 of them with a state, the verdict question of every model is asked again inverted, as a choice question with its two options swapped, in ten paraphrases, about the state padded with benign import lines and strings by 5% and 10% of its tokens, and a second time unchanged; the frozen A1 arms, the heads of A2 and S1Mal decide again under the paraphrases of their questions and on the padded states. The answer of CLM-8B to the verdict question (a yes at a probability of at least 0.5) holds under the changes of framing: 1.31% of its verdicts flip when the question is inverted, 0.00% when the options are swapped, 1.40% with 10% of padding (on the 712 files whose padded state fits the window) and 0.55% on the repeated request. Across the 10 models whose window takes the state, inversion flips between 1.31% and 61.88% of the verdicts (Liquid d1-omni-600M) and swapped options between 0.00% and 35.97% (Liquid d1-3B). The wording of a question is what moves the decisions of CLM-8B most: a paraphrase of the verdict question flips on average 26.14% of CLM-8B’s verdicts, a paraphrase of the 32 atomic questions 23.40% of the decisions of A1 (between 8.61% and 24.16% across the 13 A1 arms), and the paraphrased verdict in the text that the heads embed 23.22% of the decisions of A2. S1Mal is the decision of CLM-8B that paraphrase moves least, at 18.81%, and with 10% of padding it changes 8.59% of its decisions, fewer than A2 (11.52%) and A1 (18.03%): its trees weigh the atomic answers together with the score of the heads. The wording is therefore part of each frozen arm: S1Mal asks every question in the wording that its combiner and its heads were fitted on, the setting in which E1 measured them.

Planted text. E8 builds a robustness test suite from a seeded sub-sample of the test files, stratified by month and packing, and appends the 14 injection payloads in its bank to the strings block of the states of its malware and benign files. These include instructions to the analyst, claims that the file is benign, fabricated evidence (e.g., a trusted signature or a clean audit), completed templates and obfuscated variants. Each payload is inserted either directly or through the state builder’s sanitizer, which adds a flag line when its screen identifies analysis-directed text. The planted text affects the verdict question more than the atomic answers: it shifts 70.50% of malware verdicts toward benign, compared with 11.05% of atomic answers (Figure 9b). Each atomic

question concerns a specific behavior, so a general claim of legitimacy does not directly answer it. At τ1%\tau_{1\%}, A0’s malware TPR falls from 6.50% to 0.00%, and A1’s from 59.50% to 1.50%. Although individual atomic answers change little, A1’s combiner, fitted on clean answers, accumulates their shifts toward benign. A2 retains the highest TPR under planted text, 72.00%, down from 88.00%. However, its embedding heads also treat the planted text as evidence of maliciousness, flagging 23.26% of benign files containing it (Figure 9a). By combining atomic answers with the embedding score, S1Mal moderates both effects. Its TPR falls from 89.50% to 52.00%, while its FPR on benign files with planted text is 9.30%, less than half A2’s. The atomic answers’ shift toward benign thus reduces both detections and false alarms relative to the embedding readout.

Figure 9. Planted text in the state.

The screen identifies all 14 payloads in its bank and none of the 10 benign strings used to check it. On the development split, where it is evaluated, it flags 16.67% of benign states and 2.00% of malware states. Adding its flag line shifts A2 and S1Mal further toward benign, reducing their TPRs to 33.00% and 28.00%, respectively. Because the flag occurs more often in benign states, the trained readouts interpret it as evidence that a file is benign. The screen is therefore most useful as a separate signal to the analyst, outside the state read by the model.

Benign padding, ranging from 5% to 25% of the state, changes relatively few answers. At 25%, it moves 4.05% of atomic answers and 0.00% of verdicts. Nevertheless, small shifts across many answers, or in the overall embedding, can push scores across the threshold set at 1% FPR. Among the 111 malware files with answers at every padding level, A2’s TPR falls from 88.29% to 50.45% at 25% padding (McNemar p<0.001p < 0.001), while A1’s falls from 78.38% to 41.44%. S1Mal is the most robust: its TPR goes from 90.99% to 85.59% at 5% padding (McNemar p=0.070p = 0.070), compared with 63.96% for A2 and 63.06% for A1, and reaches 63.06% at 25%.

This robustness reflects the complementary responses of the two inputs: padding affects the atomic answers and embedding scores of different files. At 5% padding, at least one of A1 and A2 detects 82.88% of malware, while both detect 44.14%. At 25%, these proportions are 62.16% and 29.73%, respectively. By weighing both inputs, the trees in S1Mal maintain a TPR close to that of the union of the two readouts.

Drift and Out-of-Distribution Transfer

E9 follows the TPR at the frozen threshold over the nine monthly buckets of TEST and summarizes it by the area under time [31]. E10 applies the frozen arms to SOREL-20M. Every month of BODMAS precedes the release of CLM-8B (2026-09-24) and of its Qwen3-8B backbone (2025-04-29), so the models may have met these samples, or reports about them, in pretraining; the contamination controls of E10 measure what the decision owes to such recall.

Drift. Figure 10 follows the TPR at the frozen τ1%\tau_{1\%} over the 9 first-seen months of TEST. S1Mal keeps an area under time of 0.9334 ([0.885, 0.963]), with a Sen slope of -0.26 points per month (Mann-Kendall p=0.754p = 0.754) and a standard deviation of the monthly TPR of 0.023, and A2 keeps 0.9057 ([0.840, 0.946]), with +0.49 points per month (p=0.466p = 0.466) and a deviation of 0.042. The atomic answers steady the months in which the embedding score dips: in 2020-03, the lowest month of A2 at 84.02%, S1Mal detects 91.60% of the malware. Their FPR on BtestB_{\mathrm{test}}, whose files carry no dates, is 1.45% and 1.11%. No arm shows a monotone trend after Holm correction over the 5 arms of Figure 10: the smallest Hamed-Rao pp, 0.118 for A1 and for DET, becomes 0.589. The frozen System One thus holds its detection over the nine months without retraining, inside the knowledge horizon of the models, plausibly because the behaviors that its readouts capture recur in the malware of the following months. DET follows the same course at 0.8862, and the readouts that answer questions stay at the level of their TPR in E1, 0.5983 for A1 and 0.0885 for A0.

Figure 10. Detection over the test months.

Transfer and contamination. On SOREL-20M, at the frozen τ1%\tau_{1\%}, S1Mal detects 54.75% of the malware ([53.32%, 56.18%]), A2 51.87% ([50.44%, 53.31%]), DET 66.46%, A1 22.20% and A0 2.98%, each at the realized FPR of its threshold on BtestB_{\mathrm{test}} (Table 5). The gain of S1Mal over A2 is larger on packed malware, 57.58% against 53.60%, than on the other files. Against the benign files of BtestB_{\mathrm{test}}, S1Mal ranks the SOREL-20M malware at an AUROC of 0.9453 ([0.941, 0.949]), A2 at 0.9472 ([0.943, 0.951]) and DET at 0.9501 ([0.946, 0.954]). The ranking carries over to a source and a period that no component has seen, while the thresholds, fixed on the BODMAS malware of V, pass about half of the SOREL-20M malware: a new feed calls for an operating point fitted on its own validation files, with the heads and trees unchanged. The contamination controls act on the state. Removing the quoted strings and the section names leaves the ranking of A2 almost unchanged, at an AUROC of 0.9408 against 0.9474 with the whole state, and a state made of the strings alone ranks the files at 0.6548 ([0.620, 0.690]). Without the strings the scores of A2 move toward malware: at the frozen threshold its TPR goes from 52.63% to 61.34% (McNemar p<0.001p < 0.001) and its FPR from 1.17% to 2.58%. A2 thus decides on the behavioral evidence of the state, and the strings mostly weigh toward benign. S1Mal follows A2: without the strings its TPR goes from 55.47% to 61.54% (McNemar p<0.001p < 0.001) and its FPR from 1.17% to 2.34%, and the strings alone rank the files at 0.6408 ([0.606, 0.676]). The readouts that answer questions keep their TPR without the strings: A1 goes from 21.66% to 22.87% (McNemar p=0.405p = 0.405) and A0 from 4.45% to 4.05%. Samples first seen in 2026, after the release of the models, need live malware and a networked VM, outside the static and offline setting of this study.

Limitations

Some limitations emerge from the scope of the study. The evidence is static: no sample is ever executed, so behavior that appears only at run time (e.g., the payload of a packed file) stays outside the state until a sealed sandbox adds it. The local models read at most 8,192 tokens, which bounds the number of function cards in a state, and windows of 32,000 tokens would hold about four times as many. Jev, the System One model released by TypeSafe, falls outside this evaluation, since its usage policy prohibits the analysis of malware; its assessment on these states, subject to a written authorization from TypeSafe, is left to future work. The operating point rests on the 27 false positives that 1% allows among the 2,785 benign validation files with a state, so the realized FPR on BtestB_{\mathrm{test}} moves between 0.95% and 1.91% across the arms, and a benign validation set of tens of thousands of files would support thresholds at 0.1%. Benign files carry no reliable first-seen date, so E9 measures the time axis on malware, and the S2 states of benign programs are longer than those of malware (6,229 against 4,385 tokens on average in a dry run), a difference that states matched in length would isolate. BODMAS and SOREL-20M predate the models, and public reports on their families may have entered pretraining: the temporal split and the shortcut controls limit this exposure, and samples first seen after the release of the models would remove it.

Conclusion and Future Works

This work evaluates System One decision models as Windows PE malware detectors built on static analysis. An isolated virtual machine decompiles every binary with Ghidra and maps its capabilities with capa. The host renders the records into canonical textual states free of the known class shortcuts. CLM-8B and ten open decision models answer typed verdict and behavioral questions, and three readouts turn the answers or the embedding into scores calibrated at a 1% FPR operating point; S1Mal joins the atomic answers and the embedding of CLM-8B in one tree combiner. A protocol frozen before testing compares the readouts with one another, with a combiner on the digest facts and with LLMs read through answer-token probabilities on BODMAS, SOREL-20M and a matched benign collection, and compares their inference on a workstation with a laptop GPU.

The evaluation shows that a single typed verdict wastes the static evidence that a System One model reads, and that many typed answers and supervised heads on its embedding recover its signal. A single verdict ranks the files at an AUROC between 0.4025 and 0.8590, the atomic questions with a trained combiner lift every model to between 0.9126 and 0.9834, and heads on the embedding reach 0.9943 for CLM-8B and from 0.9853 to 0.9948 for nine open models. S1Mal joins the two readouts of CLM-8B: it ranks the test files at 0.9946, detects 59.15% of the malware at 0.1% FPR, stays close to the union of its inputs under padding and holds its detection over the nine test months, with an area under time of 0.9334, while each of its decisions keeps the atomic answers that name the behaviors behind it. Its results are reproducible: inference returns the same probabilities across sessions and caches, and the variance between training seeds is close to zero, with an AUROC between 0.9938 and 0.9946 over five seeds. The typed answers also stay close to the state: CLM-8B affirms 1.29% of the popular and 1.10% of the adversarial absent items and no absent capability, and planted text moves 11.05% of its atomic answers against 70.50% of its malware verdicts. Its verdict holds when the question is inverted or its options are swapped, and the wording of the questions, frozen with each arm, is what moves its decisions, least for S1Mal. The ranking carries over to SOREL-20M, at an AUROC of 0.9453 for S1Mal, and to a 5-bit model on a laptop GPU, at 0.9827 against 0.9922 in bf16, whereas the operating point is the part that each feed and each deployment tier fits on its own validation files. Finally, the question design and the combiner matter more than the wording of the questions or the extent of the state, whose blocks carry redundant evidence for the embedding.

The present work identifies several research directions that warrant further investigation. Dynamic analysis in a sealed sandbox can add run-time behavior to the state of packed files, where static capabilities are scarce, so that the same typed questions reach the behaviors that only unpacking reveals. Models with windows of 32,000 tokens or more relax the function selection of S2 and let the decision weigh functions that 8,192 tokens leave out, and Jev, the model that introduced the class, would join the same evaluation with its larger window once TypeSafe authorizes its use on decompiled malware. A benign validation set of tens of thousands of files supports thresholds at 0.1% FPR, and the abstention band can route the deferred files to a generative LLM or an analyst, with the atomic answers as the evidence shown. Benign programs dated by their release let the temporal evaluation follow the false positives over the months together with the detection. States matched in length across the classes, through the budget or through padding with neutral cards, isolate the contribution of the function content, and malware first seen after the release of the models removes any exposure of its families through pretraining. This work frames malware detection as a binary classification of each file, malicious or benign. The typed interface extends it to multiclass classification: a choice question over malware categories and families, whose labels the corpus already carries, turns the same models into a multiclass classifier that names the category and the family behind each detection. The 32 atomic questions introduce a first symbolic layer, in which each answer is judged against an explicit, rule-like criterion and learned trees combine the answers. A neuro-symbolic integration stronger than these 32 atomic rules could make the combination itself symbolic, through differentiable logic as in Logic Tensor Networks [3] or probabilistic logic programming as in DeepProbLog [25]. Both frameworks are viable candidates, since the typed answers already provide probabilities that may serve as predicates, in rules that combine behaviors and, with the multiclass answers, relate each family to its category.

Declaration of Generative AI and AI-Assisted Technologies in the Manuscript Preparation Process

During the preparation of this work, the authors used AI tools to improve the language, readability, and grammar of the manuscript, as well as to assist with debugging and bug hunting.

Question Bank

Question bank. Table 8 lists the 32 behaviors of the atomic questions. Each behavior is asked in plain language, in ATT&CK terms and in capa terms, and every question has ten paraphrases. The verdict questions are the malware question, its benign counterpart, a five-level score from “clearly benign” to “clearly malware”, and a two-option choice in both orders. The function-level questions ask eleven behaviors of a single function card and whether the function is relevant to security.

Malicious (28). Command execution; persistence through Run keys, services, scheduled tasks and the startup folder; process injection; process hollowing; privilege escalation; anti-debugging; anti-VM and sandbox checks; obfuscation and packing; disabling security tools; credential access; keylogging; screen and clipboard capture; discovery; lateral movement; command and control over HTTP, DNS and raw sockets; download and execute; dropping files; exfiltration; ransomware encryption; shadow-copy deletion; wiping; cryptocurrency mining; self-propagation.
Benign indicators (4). Graphical application; installer or updater; runtime library; low-risk operations only.

Table 8. Behaviors of the atomic question set.

Additional Results

Table 9 gives the values behind Figure 4: the AUROC of every model that reads a prompt with each of its readouts, and the number of files each model scored.

ModelStateA0A1A2S1MalFiles
AUROC [95% CI]
CLM-8BS20.7194 [0.643, 0.796]0.9763 [0.965, 0.985]0.9943 [0.991, 0.997]0.9946 [0.991, 0.997]10,829
Qwen3-8B (logits)S20.7388 [0.694, 0.779]0.9493 [0.929, 0.964]--10,829
Foundation-Sec-8B (logits)S20.8590 [0.799, 0.906]0.9733 [0.962, 0.981]--10,829
decider-4b (Q4_K_M)S00.6667 [0.595, 0.740]0.9834 [0.975, 0.989]0.9936 [0.990, 0.996]-10,829
decider-2bS00.6682 [0.574, 0.756]0.9824 [0.975, 0.988]0.9938 [0.989, 0.997]-10,829
decider-0.8bS00.5675 [0.485, 0.652]0.9773 [0.969, 0.984]0.9916 [0.987, 0.995]-10,829
Strands Decider 2BS00.6933 [0.612, 0.773]0.9833 [0.975, 0.989]0.9948 [0.992, 0.997]-10,829
Liquid d1-3BS00.5902 [0.499, 0.684]0.9792 [0.969, 0.986]0.9908 [0.986, 0.994]-10,829
Liquid d1-omni-600MS00.4025 [0.297, 0.517]0.9437 [0.921, 0.960]--10,829
Kev-0.8BS00.6930 [0.634, 0.748]0.9673 [0.954, 0.977]0.9934 [0.990, 0.996]-10,829
Von 395MS00.6957 [0.571, 0.796]0.9602 [0.942, 0.973]0.9896 [0.983, 0.994]-10,829
Laya typed-decisions 421MS00.4561 [0.323, 0.582]0.9398 [0.914, 0.959]0.9915 [0.987, 0.994]-8,316
Laya multilingual 322MS00.6524 [0.557, 0.740]0.9126 [0.881, 0.936]0.9853 [0.978, 0.991]-8,369

Table 9. Every prompt-reading model with each readout (test split).

Table 10 reports, for every arm trained with five seeds, seed 0, the primary variant of the main text, next to the mean and the standard deviation over the seeds (§ 4.4).

References

  1. [1]Hyrum S. Anderson and Phil Roth. EMBER: An open dataset for training static PE malware machine learning models. arXiv preprint arXiv:1804.04637, 2018.arxiv.org/abs/1804.04637
  2. [2]Daniel Arp, Erwin Quiring, Feargus Pendlebury, Alexander Warnecke, Fabio Pierazzi, Christian Wressnegger, Lorenzo Cavallaro, and Konrad Rieck. Dos and don’ts of machine learning in computer security. In 31st USENIX Security Symposium (USENIX Security 22), pages 3971–3988, Boston, MA, 2022. USENIX Association. arXiv:2010.09470.arxiv.org/abs/2010.09470
  3. [3]Samy Badreddine, Artur d’Avila Garcez, Luciano Serafini, and Michael Spranger. Logic Tensor Networks. Artificial Intelligence, 303:103649, 2022.DOI
  4. [4]Federico Barbero, Feargus Pendlebury, Fabio Pierazzi, and Lorenzo Cavallaro. Transcending TRANSCEND: Revisiting malware classification in the presence of concept drift. In 2022 IEEE Symposium on Security and Privacy (SP), pages 805–823. IEEE, 2022.arxiv.org/abs/2010.03856
  5. [5]Ero Carrera. pefile: A Python module to read and work with PE (Portable Executable) files. GitHub repository, https://github.com/erocarrera/pefile, 2024. Version 2024.8.26.
  6. [6]Aniesh Chawla and Udbhav Prasad. A decompilation-driven framework for malware detection with large language models. In 2025 IEEE 16th Annual Information Technology, Electronics and Mobile Communication Conference (IEMCON), pages 403–408. IEEE, 2025.
  7. [7]Zheng Chen, Fei Yu, Haohao Huang, Yang Li, Anlong Chen, and Lei Chen. SecJev: Bringing security expertise to System One decision models. arXiv preprint arXiv:2610.03073v2, October 2026.arxiv.org/abs/2610.03073
  8. [8]Hyeongjun Choi. MARS: Malware analysis with rule-based scoring of LLM claims. arXiv preprint arXiv:2610.09553, October 2026.arxiv.org/abs/2610.09553
  9. [9]Hyeongjun Choi, Wonyoung Jung, Haehoon Seo, and Sungyup Nam. ALIBI: Adversarial legitimacy injection in binary input against LLM malware analyzers. arXiv preprint arXiv:2609.19722, September 2026.arxiv.org/abs/2609.19722
  10. [10]ggml-org. llama.cpp: LLM inference in C/C++. GitHub repository, https://github.com/ggml-org/llama.cpp, 2026. Builds b11429 and b11535.
  11. [11]Chuan Guo, Geoff Pleiss, Yu Sun, and Kilian Q. Weinberger. On calibration of modern neural networks. In Doina Precup and Yee Whye Teh, editors, Proceedings of the 34th International Conference on Machine Learning, volume 70 of Proceedings of Machine Learning Research, pages 1321–1330. PMLR, 2017. arXiv:1706.04599.arxiv.org/abs/1706.04599
  12. [12]Richard Harang and Ethan M. Rudd. SOREL-20M: A large scale benchmark dataset for malicious PE detection. In Edward Raff, Hyrum Anderson, and Sagar Samtani, editors, Proceedings of the Conference on Applied Machine Learning in Information Security (CAMLIS 2021), volume 3095 of CEUR Workshop Proceedings, pages 13–21. CEUR-WS.org, 2021. arXiv:2012.07634.arxiv.org/abs/2012.07634
  13. [13]Hors. Detect It Easy: Program for determining types of files for Windows, Linux and MacOS. GitHub repository, https://github.com/horsicq/Detect-It-Easy, 2026. Version 3.21.
  14. [14]Robert J. Joyce, Gideon Miller, Phil Roth, Richard Zak, Elliott Zaresky-Williams, Hyrum Anderson, Edward Raff, and James Holt. EMBER2024 - a benchmark dataset for holistic evaluation of malware classifiers. In Proceedings of the 31st ACM SIGKDD Conference on Knowledge Discovery and Data Mining V.2 (KDD ’25), pages 5516–5526. ACM, 2025.DOI
  15. [15]ElMouatez Billah Karbab. AsmRAG: LLM-driven malware detection by retrieving functionally similar assembly code. arXiv preprint arXiv:2604.23196, April 2026.arxiv.org/abs/2604.23196
  16. [16]Maciej Kisielewicz, Michał Kędziora, and Ngoc Thanh Nguyen. Escalate or close: How fast-tier models handle held-out web attack families in two-tier triage. arXiv preprint arXiv:2611.08229, November 2026.arxiv.org/abs/2611.08229
  17. [17]Luke Kurlandski, Harel Berger, Yin Pan, and Matthew Wright. Beyond raw bytes: Towards large malware language models. In Proceedings 2026 Network and Distributed System Security Symposium (NDSS). Internet Society, 2026.DOI
  18. [18]Jacky Kwok, Hangoo Kang, Tarun Suresh, Jon Saad-Falcon, Marco Pavone, Christopher Ré, and Azalia Mirhoseini. CLM: Contrastive language models. GitHub repository, https://github.com/Contrastive-LM/CLM, 2026. Model CLM-v0.1-8B.
  19. [19]Qianlong Lan, Anuj Kaul, Vinothini Pandurangan, and Indranil Sanyal. From detection to decision: Calibration and deferral for prompt-injection detection. arXiv preprint arXiv:2610.20907, October 2026.arxiv.org/abs/2610.20907
  20. [20]Yifan Li, Yifan Du, Kun Zhou, Jinpeng Wang, Wayne Xin Zhao, and Ji-Rong Wen. Evaluating object hallucination in large vision-language models. In Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing, pages 292–305. Association for Computational Linguistics, 2023.arxiv.org/abs/2305.10355
  21. [21]Yixuan Liu. Evaluating System One models for agent security decisions: Reliability, calibration, and selective automation. arXiv preprint arXiv:2609.33401v3, September 2026.arxiv.org/abs/2609.33401
  22. [22]Nandakishor M and Anjali M. From Laya to Vega: Open non-autoregressive decision models with calibrated probabilities. Preprints, November 2026. Preprint 2026110781, version 1.DOI
  23. [23]Mandiant FLARE Team. FLOSS: FLARE obfuscated string solver. GitHub repository, https://github.com/mandiant/flare-floss, 2024. Version 3.1.1.
  24. [24]Mandiant FLARE Team. capa: The FLARE team’s open-source tool to identify capabilities in executable files. GitHub repository, https://github.com/mandiant/capa, 2026. Version 9.4.0 with rules v9.4.0.
  25. [25]Robin Manhaeve, Sebastjan Dumančić, Angelika Kimmig, Thomas Demeester, and Luc De Raedt. Neural probabilistic logic programming in DeepProbLog. Artificial Intelligence, 298:103504, 2021.arxiv.org/abs/1907.08194
  26. [26]Mark Marosi. decider: one-pass typed decisions with calibrated probabilities. GitHub repository, https://github.com/Mapika/decider, 2026. Checkpoints decider-0.8b, decider-2b and decider-4b-GGUF.
  27. [27]National Security Agency. Ghidra: A software reverse engineering (SRE) framework. GitHub repository, https://github.com/NationalSecurityAgency/ghidra, 2026. Version 12.1.4.
  28. [28]Andre T. Nguyen, Edward Raff, Charles Nicholas, and James Holt. Leveraging uncertainty for improved static malware detection under extreme false positive constraints. arXiv preprint arXiv:2108.04081, 2021.arxiv.org/abs/2108.04081
  29. [29]Jared Palmer. Kev: Jev-like family of decision models built on top of Qwen3.5/3.8. GitHub repository, https://github.com/jaredpalmer/kev, 2026. Model Kev-0.8B.
  30. [30]Victor Hugo Panisa. Von: An open-source System One decision model. GitHub repository, https://github.com/wfzyx/von, 2026. Von 1.3.
  31. [31]Feargus Pendlebury, Fabio Pierazzi, Roberto Jordaney, Johannes Kinder, and Lorenzo Cavallaro. TESSERACT: Eliminating experimental bias in malware classification across space and time. In 28th USENIX Security Symposium (USENIX Security 19), pages 729–746, Santa Clara, CA, 2019. USENIX Association. arXiv:1807.07838.arxiv.org/abs/1807.07838
  32. [32]John C. Platt. Probabilities for SV machines. In Alexander J. Smola, Peter Bartlett, Bernhard Schölkopf, and Dale Schuurmans, editors, Advances in Large-Margin Classifiers, pages 61–74. The MIT Press, 2000.DOI
  33. [33]Amir Rafe and Subasish Das. Benchmarking System One decision models against trained classifiers and language models for automated decision gates. arXiv preprint arXiv:2610.00346v2, September 2026.arxiv.org/abs/2610.00346
  34. [34]Edward Raff, William Fleshman, Richard Zak, Hyrum S. Anderson, Bobby Filar, and Mark McLean. Classifying sequences of extreme length with constant memory applied to malware detection. Proceedings of the AAAI Conference on Artificial Intelligence, 35(11):9386–9394, 2021.
  35. [35]Melanie Sclar, Yejin Choi, Yulia Tsvetkov, and Alane Suhr. Quantifying language models’ sensitivity to spurious features in prompt design or: How I learned to start worrying about prompt formatting. In International Conference on Learning Representations (ICLR), 2024. arXiv:2310.11324.arxiv.org/abs/2310.11324
  36. [36]Strands Agents. Strands Decider: A small, fast decision model for agentic AI. GitHub repository, https://github.com/strands-labs/strands-decider, 2026. Checkpoint strands-decider-2B-qwen3.5-v1-2610.
  37. [37]Yilin Sun and Mohammad Masum. PE2Prompt: a large language model-native framework for interpretable static malware analysis. Knowledge-Based Systems, 351:116854, 2026.
  38. [38]Bercan Turkmen and Vyas Raina. Multi-view decompilation for LLM-based malware classification. arXiv preprint arXiv:2606.20436, June 2026.arxiv.org/abs/2606.20436
  39. [39]Hao Wang, Zeyu Gao, Chao Zhang, Zihan Sha, Mingyang Sun, Yuchen Zhou, Wenyu Zhu, Wenju Sun, Han Qiu, and Xi Xiao. CLAP: Learning transferable binary code representations with natural language supervision. In Proceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA ’24), pages 503–515. ACM, 2024.arxiv.org/abs/2402.16928
  40. [40]Sajana Weerawardhena, Paul Kassianik, Blaine Nelson, et al. Llama-3.1-FoundationAI-SecurityLLM-8B-Instruct technical report. arXiv preprint arXiv:2508.01059, 2025.arxiv.org/abs/2508.01059
  41. [41]David H. Wolpert. Stacked generalization. Neural Networks, 5(2):241–259, 1992.DOI
  42. [42]An Yang, Anfeng Li, Baosong Yang, et al. Qwen3 technical report. arXiv preprint arXiv:2505.09388, 2025.arxiv.org/abs/2505.09388
  43. [43]Limin Yang, Arridhana Ciptadi, Ihar Laziuk, Ali Ahmadzadeh, and Gang Wang. BODMAS: An open dataset for learning based temporal analysis of PE malware. In 2021 IEEE Security and Privacy Workshops (SPW), pages 78–84. IEEE, 2021.DOI
  44. [44]Limin Yang, Wenbo Guo, Qingying Hao, Arridhana Ciptadi, Ali Ahmadzadeh, Xinyu Xing, and Gang Wang. CADE: Detecting and explaining concept drift samples for security applications. In 30th USENIX Security Symposium (USENIX Security 21), pages 2327–2344. USENIX Association, 2021.
  45. [45]Yanzhao Zhang, Mingxin Li, Dingkun Long, et al. Qwen3 Embedding: Advancing text embedding and reranking through foundation models. arXiv preprint arXiv:2506.05176, 2025.arxiv.org/abs/2506.05176

Paper details

vlnc:W_ca3ncefg
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

AI tools

View statement
Looking for related papers…
Contents