betaFeedback

WorksComputer Science

TRIAGE-CPG: A Cross-Model Study of Budgeted Static Malware Triage with Large Language Models

Abstract

When triaging unknown binaries, security analysts must decide which samples to clear as benign, flag as malicious, or escalate for deeper analysis. Large Language Models (LLMs) could support these decisions by interpreting decompiled code, but a binary can contain hundreds or thousands of functions, making exhaustive LLM analysis impractical. We study how current LLMs behave when static triage is formulated as budgeted evidence acquisition: which functions they inspect and how they trade off benign clearance, malware detection, and escalation. To enable a controlled comparison, we implement TRIAGE-CPG, a fixed pipeline over a code property graph (CPG) of a decompiled binary. An LLM-free heuristic selects seed functions, an agent expands the resulting evidence dossier under a fixed budget, and a reporting stage produces a benign, suspicious, or malicious verdict together with a behavioral report. We evaluate eight closed-source and open-weight models on 1,000 Windows PE binaries, using a 600-sample test split and the same zero-shot protocol for every model. We assess the ternary verdicts under both a strict binary reading and triage balanced accuracy (tBA), which credits malware that is flagged or escalated and benign samples only when cleared. After analyzing about 40 of a mean 1,000 functions per binary, the highest-scoring model reaches a strict balanced accuracy of 0.805 and a tBA of 0.855, flagging 65% of malware, escalating another 12%, and clearing 94% of benign samples. The models implement different triage policies: high-specificity models produce small, malware-rich escalation queues, whereas recall-oriented models escalate or flag much more broadly. Both closed-source and open-weight models appear across this spectrum. Our results identify no universal deployment configuration: model choice itself determines the clear/flag/escalate trade-off under limited static evidence.

CCS Concepts: • Security and privacy → Malware and its mitigation; Software reverse engineering; • Computing methodologies → Intelligent agents; Natural language processing.

ACM Reference Format: Paul-Andrei Sava, Alexander Küchler, Daniel Kowatsch, Bernhard Grill, Jennifer Pullman, Yanick Fratantonio, and Luca Invernizzi. 2026. TRIAGE-CPG: A Cross-Model Study of Budgeted Static Malware Triage with Large Language Models. In 19th Workshop on Artificial Intelligence and Security (AISec ’26), November 15–19, 2026, The Hague, Netherlands. ACM, New York, NY, USA, 12 pages. https://doi.org/10.1145/3847352.3848112

Introduction

Threat hunters face large volumes of unknown binaries and must decide quickly and safely which ones deserve scarce human attention [2, 3]. Dynamic analysis is the de facto standard [9], but it is costly [4], requires a secure environment in which it can execute the sample [13], and can still be evaded by environment-aware [18, 26] or stalling malware [19, 21]. On the other hand, static analysis avoids execution and can in principle inspect the entire program, but may be impeded by packing and obfuscation [28]. It also carries a scaling cost: a single binary can decompile into hundreds or thousands of functions [25], far more than an analyst or a fixed LLM context window can read. These constraints motivate a bounded first pass that clears likely benign samples, flags samples with malicious evidence, and escalates cases that cannot be resolved from available static evidence.

The consequences of these decisions are asymmetric. Within an intake workflow, clearing malware as benign is difficult to recover from because the sample leaves the analysis queue. Escalating a benign sample does consume downstream analysis resources, but the error can still be corrected. A triage procedure should therefore expose uncertainty rather than forcing every sample into a committed benign or malicious verdict. We represent this uncertainty through a third verdict, suspicious, which routes the sample to deeper analysis.

This work is licensed under a Creative Commons Attribution 4.0 International License.

AISec ’26, The Hague, Netherlands

© 2026 Copyright held by the owner/author(s).

ACM ISBN 979-8-4007-3031-3/2026/11

https://doi.org/10.1145/3847352.3848112

Large Language Models (LLMs) are a plausible tool for this setting because they can interpret decompiled code and use external tools to acquire additional context [40] [41]. Code property graphs (CPGs) provide a corresponding navigation substrate by combining call relationships with control- and data-flow information in a queryable program representation [36, 39]. However, these capabilities do not remove the underlying scale constraint. Whole binaries remain too large or costly to inspect exhaustively [35], many recovered functions contain boilerplate or library code, and unbounded agent exploration is expensive and difficult to compare reproducibly [27]. This raises the empirical question we study: how do current LLMs behave when they must triage a binary from a small, graph-selected subset of its functions, and how does model choice affect the balance between clearance, malware detection, and escalation?

To investigate this question, we introduce TRIAGE-CPG, a fixed, graph-guided pipeline for static triage of Windows PE binaries. The system receives a CPG obtained from a decompiled binary together with its PE metadata and operates in three stages. First, an LLM-free heuristic ranks the recovered functions and analyzes the highest-ranked ones to initialize an evidence dossier. Second, an agent expands this dossier by following call-graph leads under a fixed exploration budget. Finally, a reporting agent reviews the frozen dossier and returns a benign, suspicious, or malicious verdict together with a behavioral report. TRIAGE-CPG therefore provides a common evidence interface through which different models can be compared under the same constraints.

We evaluate the ternary verdicts under two complementary readings: a strict reading, in which only a committed malicious verdict counts as positive, and a triage reading, in which malware counts as handled when flagged or escalated while a benign sample counts only when cleared. We call balanced accuracy under the latter triage balanced accuracy (tBA) and report it alongside the strict reading and explicit escalation-queue measurements.

We compare eight closed-source and open-weight models on a locked test set of 600 Windows PE binaries under one uniform, zero-shot protocol. The fixed pipeline is intended to isolate differences in model behavior rather than to optimize a separate configuration for each model. Under this protocol, the highest-scoring model reaches a tBA of 0.855 while inspecting approximately 40 recovered functions per binary. It flags or escalates 77% of malware and clears 94% of benign samples.

The models also do not converge on a common triage policy. High-specificity models clear most benign samples and produce small, malware-rich escalation queues, but issue fewer committed malware verdicts. Recall-oriented models flag or escalate more broadly, catching more malware at the cost of routing substantially more benign samples to further analysis. Both closed-source and open-weight models appear across this spectrum, so model choice is not just an implementation detail: under otherwise identical conditions, it determines the operating point of the triage workflow.

Our Contributions. We make the following contributions:

  • We formulate static LLM malware triage as budgeted, escalation-oriented evidence acquisition. We define and evaluate triage balanced accuracy (tBA), the balanced accuracy of the clear-versus-not-clear decision, and report it together with a strict verdict reading and explicit escalation-queue metrics.

  • We introduce TRIAGE-CPG as a controlled evidence interface for studying this setting. The pipeline combines LLM-free function prioritization, bounded CPG exploration, and ternary adjudication while holding the available evidence and action budgets fixed across models.

  • We conduct a fixed-protocol comparison of eight closed-source and open-weight models on a locked 600-binary test split. We find that models occupy substantially different recall–specificity and escalation operating points, showing that model choice itself determines the resulting triage policy.

Approach

TRIAGE-CPG processes each Windows PE binary through a common evidence interface in two phases. A preprocessing step decompiles the binary with Ghidra1, constructs a code property graph (CPG), and extracts PE metadata. The resulting static evidence is then passed to a three-stage LLM workflow, shown in Figure 1: an LLM-free heuristic selects seed functions and initializes an evidence dossier, an exploration agent follows leads through the graph under a fixed budget, and a reporting agent reviews the collected evidence and produces a ternary verdict and behavioral report.

TRIAGE-CPG pipeline showing static evidence, seed analysis, evidence exploration, verdict reporting, an evidence dossier, and escalation queue

Figure 1. TRIAGE-CPG pipeline. The CPG and PE metadata of a decompiled Windows PE binary provide the static evidence. EPS selects seed functions to initialize a dossier; an exploration agent may expand it under a fixed function-read budget. A reporting agent reads the frozen dossier and returns a ternary verdict and behavioral report; suspicious samples are escalated.

The reported evidence budget covers model actions used to analyze functions or inspect the dossier. It does not include decompilation or CPG construction and therefore measures model-facing evidence use rather than end-to-end analysis time. Section 2.2.1 describes the seeding heuristic, while § 2.2.2 and § 2.2.3 present the exploration and reporting stages.

CPG-based Evidence Representation

The preprocessing stage constructs the CPG using an open-source, language-independent implementation [36]. The CPG represents syntax, control flow, data flow, call relationships, and program dependence in a single queryable graph. This representation is useful for LLM-assisted analysis because it supports the extraction of bounded program context even when the available code is incomplete, as is common in decompiled binaries [22, 36]. Furthermore, it serves as abstract representation for different types of malware.

Although the constructed CPG retains control-flow, data-flow, call, and program-dependence edges, the workflow evaluated in this paper uses only its function-level call-graph projection. Future extensions, however, can make use of the more powerful sub-graphs to enhance the analysis capabilities. E.g., program slicing can reduce the LLM input to the required context only, or the built-in data-flow analysis can be extended to taint-style analysis providing additional signals to identify relevant code regions.

Each node in the CPG represents a recovered function together with its decompiled body. Internal edges represent calls between recovered functions, while calls without a matching in-binary function are represented as external API references. Callers and callees provide the graph relations exposed to the exploration agent. The function is also the unit charged to the evidence budget: analyzing a function reveals its complete decompiled body. The remaining CPG edge types are retained in the serialized representation but are not queried by the evaluated workflow and therefore do not affect the reported verdicts. Our results thus characterize call-graph-guided evidence acquisition rather than the full range of analyses a CPG can support.

Alongside the call-graph projection, the model receives PE metadata comprising the file and optional headers, the section table and per-section entropies, the import and export tables, embedded resources, and file hashes. § 4.1 evaluates the effect of including this metadata by comparing the fixed pipeline with and without it.

Triage as Budgeted Evidence Acquisition

Because the system cannot inspect every recovered function, it must decide where to spend a limited number of function analyses. We therefore formulate triage as evidence acquisition under a budget: the pipeline selects a subset of functions, records the resulting analyses in a shared dossier, and derives its verdict only from the evidence acquired within that allowance.

The budget is divided across the three workflow stages:

  • The seeding budget determines how many functions are selected by the fixed ranking heuristic and analyzed to initialize the evidence dossier.

  • The exploration budget limits how many additional functions the agent may analyze while following leads through the call graph.

  • The reporting budget limits how many read-only dossier inspections the reporting agent may perform before returning its verdict.

The exploration and reporting stages may stop before exhausting their respective allowances. This design holds the maximum evidence budget and available actions fixed across models while allowing their stopping behavior and choice of exploration targets to differ.

Seed Analysis

Seed analysis initializes the evidence dossier. For a given binary, every evaluated model starts from the same ranked set of seed functions, so initial selection cannot confound the cross-model comparison, though the model-generated analyses of those functions may differ.

We use a recall-oriented seed policy. In the development experiments, later exploration rarely recovered malware whose relevant evidence was missed during seeding, as § 4.3 shows. The selected policy therefore favors an initial operating point with high malware recall, leaving later stages to resolve false alarms when additional context permits.

Each function receives an Evidence Priority Score (EPS), defined as a weighted combination of features derived from its decompiled body and its position in the call graph.

EPS⁡(f)=0.25 PR⁡out(f)+0.50 B(f)+0.25 C(f).(1)\operatorname{EPS}(f) = 0.25\,\operatorname{PR}_{\mathrm{out}}(f) + 0.50\,B(f) + 0.25\,C(f). \tag*{(1)}

PR⁡out\operatorname{PR}_{\mathrm{out}} is PageRank computed on the reverse call graph and measures the structural prominence of ff as a caller. The boundary indicator B(f)B(f) equals one when ff calls at least one imported API and has either zero internal in-degree or zero internal out-degree. The degree condition constrains only ff's position in the internal call graph, so a root that no recovered function calls qualifies even when it calls internal functions alongside imported APIs.

C(f)C(f) is the log-scaled length of the decompiled function body, normalized within the binary:

C(f)=log⁡(1+∣code⁡(f)∣)max⁡g∈Flog⁡(1+∣code⁡(g)∣),C(f) = \frac{\log(1 + |\operatorname{code}(f)|)}{\max_{g \in F}\log(1 + |\operatorname{code}(g)|)},

where FF is the set of recovered functions in the binary. It is a simple proxy for the amount of code available for analysis.

EPS thus combines three inexpensive signals: caller prominence, interaction with imported APIs at a call-graph boundary, and decompiled body length. The weights were selected from a grid search over 70 weight vectors on the training split, reported in Appendix A. We do not treat this weighting as uniquely optimal, and compare EPS with several alternative selectors in § 4.2.

Each of the kk highest-scoring seed functions is analyzed once by the evaluated LLM. The model receives the decompiled function body and is asked to separate the mechanism implemented by the code from any inference about its intent. Because many low-level operations are dual-use, the prompt asks the model to consider plausible benign explanations rather than treating a suspicious mechanism as sufficient evidence of malware. For each function, the model returns a summary, a suspicion score between zero and one, the capabilities supported by the code, and the strongest benign explanations. These fields form the function’s record in the evidence dossier.

Evidence Exploration

During exploration, an agent may expand the initial dossier by acquiring evidence from functions that were not selected as seeds. Its state consists of a running scratchpad containing its current hypothesis, a history of previous actions, and a summary of each analyzed function. At every step, the agent also receives the latest tool result, the PE metadata, and its remaining function-analysis budget.

The agent may analyze an unread function, list a function’s callers or callees, find functions that call a specified API, or stop. Only analyze consumes the function-analysis budget, while graph queries are free. The agent is instructed to explore when the existing dossier is insufficient and may stop early when it considers the evidence sufficient. Unused budget receives no explicit reward, so differences in budget use reflect how models respond to the same evidence and stopping instruction. To bound query-only exploration, the stage terminates after ten consecutive actions without a successful analyze call. It otherwise ends when the agent stops or exhausts its analysis budget.

Verdict Reporting

The reporting agent operates on a frozen evidence dossier. It cannot analyze additional code or issue new graph queries and may only inspect the evidence collected during seeding and exploration. This separation prevents the reporting stage from changing the evidence set while adjudicating it.

The agent must return one of three verdicts. Benign and malicious are committed decisions. Suspicious indicates that the collected evidence does not support either committed verdict and is interpreted as escalation to deeper analysis. The prompt cautions the model that an unsuccessful graph query is not evidence that a capability is absent and that high confidence in a benign verdict requires inspection of the likely execution path. The final structured report contains the verdict and confidence, the supporting functions and evidence, the identified capabilities, a concise rationale, and a recommended next step.

All evaluated models receive the same zero-shot stage instructions, action schemas, and budget limits. No prompt or tool interface is tuned for an individual model. The complete prompts and structured output schemas are included in the accompanying artifact.

Experimental Setup

This section describes how we evaluate TRIAGE-CPG: Section 3.1 introduces the dataset and its splits, Section 3.2 the models and locked protocol, and Section 3.3 the metrics.

Dataset and Splits

Our dataset consists of 1,000 Windows PE binaries sampled from VirusTotal. When constructing the dataset, we required zero VirusTotal detections for benign and at least ten for malware. We use these high-consensus criteria as evaluation labels rather than definitive ground truth. Samples with 1–9 detections were excluded, so our results do not characterize binaries on which VirusTotal engines disagree.

We include only binaries that yield a CPG with at least one valid function and exclude .NET binaries, which the CPG implementation does not support. The evaluation is therefore conditional on successful CPG extraction. The samples are balanced by label (500 benign, 500 malicious) and across five file-size quantiles computed separately for each class. This ensures that neither class concentrates in a single size regime.

We partition the data into three disjoint splits: a train split (200) for selecting the EPS weights, a development split (200) for ablations and budget selection, and a locked test split (600) used once for the cross-model comparison. This gives 20 samples per label–quantile cell in train and development splits, and 60 in the test split.

Overall, the binaries have a median of about 300 recovered functions, a mean near 1,200, and a long tail reaching roughly 49,500. File sizes span roughly 1 KB to 141 MB (median 501 KB), and benign binaries are larger than malicious ones (median 682 vs. 354 KB). Figure 2 shows the function counts by label: both distributions are heavily right-skewed, and benign binaries are also function-denser than malicious ones (median 364 vs. 207). This scale motivates budgeted inspection, since whole-binary prompting or exhaustive per-function analysis would require processing hundreds to thousands of functions per sample.

Figure 2. Recovered functions per binary by label (log scale). Boxes show the interquartile range and median, diamonds the mean, and dots individual binaries. Counts reach 49,519 (median 304; mean 1,208), with benign binaries denser than malicious ones.

Models and Protocol

We selected eight models based on their availability on Vertex AI at experiment time. These comprise three closed-source Gemini models (Gemini 3.1 Pro, Gemini 3.5 Flash, and Gemini 3.1 Flash-Lite) and five open-weight models spanning several families and sizes (DeepSeek V4 Pro, GLM 5.2, Gemma 4 31B, Qwen 3.6 27B, and Gemma 4 26B). The selection is not exhaustive and reflects platform availability rather than a global model ranking.

All models ran under the same configuration, selected on the development split and locked before the test runs. The seed stage selected k=min⁡(max⁡(0.1∣F∣,10),75,∣F∣)k = \min(\max(0.1|F|, 10), 75, |F|) functions by EPS, where ∣F∣|F| is the number of recovered functions. The exploration agent received an allowance of 30 analyze calls and was shown the remaining allowance at every step. Exploration ended when the agent selected done, exhausted this allowance, or performed ten consecutive actions without a successful analyze call. The reporting agent received an allowance of 20 dossier-inspection actions. PE metadata was included by default and ablated separately in Table 1. These values define the common operating point used for comparison, not a globally optimal configuration.

InputBal. Acc.RecallSpec.FP/FN
Metadata only (strict)0.5050.0101.0000/99
Metadata only (triage)0.7701.0000.54046/0
Code only0.6700.9000.44056/10
Code + metadata0.7950.8900.70030/11

Table 1. Development-split evidence ablation (Gemini 3.1 Flash-Lite). Metadata-only rows use both verdict readings; code rows use fixed seeding without exploration under the strict reading.

Each model was evaluated once per binary at temperature 0, without model-specific tuning of prompts, budgets, or decoding parameters. Because the pipeline makes dozens of model calls per binary, repeating the complete test evaluation would require tens of thousands of additional calls per model. Even at temperature 0, API-served models do not produce deterministic outputs. We therefore estimated run-to-run variation by repeating the fixed Gemini 3.1 Flash-Lite configuration three times on the development split. The runs agreed on 91% of verdicts and spanned 1.5 balanced-accuracy points, with most disagreements involving a change to or from the suspicious verdict. We use this 1.5-point span as an empirical reference and avoid drawing conclusions from smaller cross-model differences.

Metrics

We evaluate the ternary verdicts under two readings. Under the strict reading, only a committed malicious verdict counts as a positive prediction. This reading isolates committed malware calls from cases where the model defers as suspicious. Under the triage reading, a malware sample is handled correctly if it is deemed malicious or escalated, while a benign sample is handled correctly only when it is cleared. We call balanced accuracy under this reading the triage balanced accuracy (tBA) and use it as the primary triage-oriented metric, since it captures silent malware clears and benign samples routed to further analysis. Writing vv for the verdict,

tBA=12(Pr⁡[v≠benign∣malware]+Pr⁡[v=benign∣benign]),\mathrm{tBA} = \frac{1}{2}\left(\Pr[v \ne\mathrm{benign} \mid\mathrm{malware}] + \Pr[v = \mathrm{benign} \mid\mathrm{benign}]\right),

which is equivalently the balanced accuracy of the clearing decision: a malware sample must not be cleared, while a benign sample must be. A model that escalates every sample obtains a tBA of 0.5, providing no improvement over the chance-level balanced-accuracy baseline. By design, tBA does not distinguish a committed malicious verdict from an escalation on a malware sample, so we never report it alone: the strict reading identifies committed malicious decisions, while the escalation quantities below characterize the queue created by suspicious verdicts. The two readings are the extreme points of a cost-charged family in the error–reject tradition [6], so any intermediate assumption about the cost of an escalation yields a value between the strict and triage numbers we report. The gap between them measures how much a model’s performance rests on escalation rather than committed verdicts. From the confusion matrix of either reading, we report recall (the fraction of malware caught), specificity (the fraction of benign samples cleared), precision, and balanced accuracy. Since the dataset is balanced, accuracy and balanced accuracy coincide, and we report balanced accuracy throughout.

For the suspicious verdict itself, we report two escalation quantities. Coverage is the share of samples marked suspicious. Precision is the fraction of suspicious samples that are malware. Because the benchmark is balanced at a 0.5 malware base rate, a precision above 50% means the escalation queue is richer in malware than the dataset as a whole.

Evaluation

We organize the evaluation around four research questions, each answered in a dedicated subsection:

RQ1 What is the impact of the PE metadata on the verdict?

RQ2 Which functions should the seed budget be spent on first?

RQ3 What does the exploration stage add?

RQ4 How do the models differ in their triage behavior under the same frozen protocol?

RQ1–RQ3 characterize design choices in the fixed workflow using the development split and Gemini 3.1 Flash-Lite, which we chose for its low cost and fast inference. Their outcome is the frozen configuration of Section 3.2. These design choices were made under the strict reading and before any test-split run, so the primary tBA metric played no role in selecting the configuration.

RQ4 evaluates that frozen configuration across eight models on the locked test split, which is touched exactly once. The escalation and cascade analyses are post-hoc analyses of the locked test outputs, not newly tuned decision rules.

Impact of PE Metadata

Before asking which functions to inspect, we check what evidence the model needs to reach a verdict. Table 1 compares the triage performance when using only the PE metadata, the CPG alone, and the CPG with the PE metadata.

Given only the PE metadata, the model commits to a malicious verdict for one of the 100 malware samples (strict recall 0.010). It marks 145 of the 200 binaries (72.5%) as suspicious, 99 of the malware samples and 46 benign ones, which drives the triage recall to 1.000 at a specificity of only 0.540. In this development configuration, metadata alone raises suspicion broadly but rarely supports a committed malicious verdict. Code evidence is more discriminative, while adding PE metadata reduces false positives from 56 to 30 at nearly unchanged recall. Thus, PE metadata acts as a benign prior in this experiment, while code supplies most of the verdict-separating evidence.

Answer to RQ1: Code supplies most of the verdict-separating evidence, while PE metadata primarily reduces false positives, so we retain both in the fixed protocol.

EPS as a Prioritization Signal

The seed stage must choose which functions to analyze before any model call has been made. For each binary in the development split, we rank the recovered functions with EPS and with six alternatives: largest code body, out-degree, in-degree, number of API calls, EPS without its code term, and a random selector, run five times with different draws. Each selector’s top-ranked functions are analyzed and adjudicated directly, with the exploration stage disabled, so the comparison isolates seeding quality.2

Figure 3 plots each selector’s recall and specificity, and the comparison contains a null result that we consider informative: the tested inexpensive ranking signals perform similarly on the development split. EPS (0.775 balanced accuracy), out-degree (0.785), and largest code body (0.765) land within two points of each other, and even the mean random selector reaches 0.724. The competitive performance of the largest-code selector is consistent with code and graph evidence being concentrated in larger functions: the largest tenth of a binary’s functions holds a median of 26% of its external API calls and 26% of its internal call edges, a 2.6–2.9× enrichment over proportional coverage. The selectors also differ in their position on the recall–specificity frontier, as depicted in Figure 3. EPS is the most recall-oriented selector, catching 92% of malware at 0.63 specificity under the strict reading, while the only other alternative matching this recall, ranking by API count, results in a specificity of 0.51. This position is not an artifact of picking the same functions as the other heuristics. Per binary, only a median 33% of EPS seeds appear in the largest-code seed set and 23% in the out-degree seed set. We argue in § 4.3 that a recall-heavy seeder is the right choice for this pipeline, because the exploration stage recovers specificity but does not recover missed malware.

Figure 3. Development-split seed-selector performance (strict verdict, exploration off). Diagonals mark constant balanced accuracy, so selectors on a common line perform equally well. The random baseline is the mean of five runs.

Seed-budget sensitivity. The fixed schedule analyzes 10% of the recovered functions, with a floor of 10 and a cap of 75. The fixed-count sweep across binary-size classes in Appendix A supports the proportional term: no single seed count serves all sizes, and performance decreases when too many low-ranked functions are included. The choice of upper cap is less clear-cut. Table 2 varies it under the full pipeline on the development split. Lowering the cap to 50 improves balanced accuracy by cutting false positives, at the price of two more missed malware samples under the strict reading. Raising it to 100 recovers additional malware but adds false positives and cost, with balanced accuracy unchanged from the 75 limit, and the change helps and hurts nine binaries each. No fixed limit dominates all goals. We freeze cap 75 for the locked evaluation as a recall-biased, cost-controlled middle point, consistent with the recall-first result of § 4.3.

CapAvg. analyzedBal. Acc.RecallSpec.FP/FN
5035.50.8200.8700.77023/13
7544.80.7900.8900.69031/11
10052.00.7900.9100.67033/9

Table 2. Development-split seed-cap sensitivity under the full pipeline and strict verdict; all other configuration values are fixed.

Answer to RQ2: Several inexpensive static selectors perform similarly. We select EPS because it occupies the recall-oriented end of their recall–specificity frontier, which is preferable when later exploration rarely recovers missed malware.

Impact of the Exploration Stage

The exploration stage lets the agent read functions the static ranking did not select. We measure its contribution on the development split in three ways: switching it off, replacing the agent’s target choice with random draws, and re-running the seed selectors of § 4.2 under the full pipeline.

Exploration primarily corrects false positives. Table 7a pairs runs with and without exploration across nine seed and reporting configurations, and counts per-binary verdict flips. The effect appears to concentrate on the benign side. Pooled over the nine configurations and counting each binary once by its net flip direction, exploration corrects 30 benign binaries and hurts 11 (sign test clustered by binary, p=0.004p = 0.004), while for malware it shows no consistent effect (corrects 9, hurts 18, p=0.12p = 0.12). The fixed configuration shows the same picture, clearing ten additional benign binaries while catching no additional malware. In these configurations, the observable effect of exploration is therefore primarily the resolution of false alarms rather than the recovery of malware missed during seeding.

Guided targeting does not improve accuracy but stops early. A natural question is whether the agent’s choice of exploration targets matters at all. We replace the agent’s target choice with uniformly random draws over unanalyzed functions in three full-budget and three action-matched random arms (Table 7b). On accuracy, the comparison is mixed, and no difference reaches significance. This null result bounds the contribution of agentic target selection in this setting. The agent’s remaining advantage is economy: it decides when to stop and halts after an average of 5.2 additional function reads per binary, whereas the random policies have no stopping rule and spend their full allowance of 11.3 to 25.4 reads without an accuracy gain. We return to what the agent actually read, across all eight models, in § 4.4.

Exploration rarely recovers seed misses. Re-running the seed selectors under the full pipeline, reported in Table 7c, connects the two findings above. Exploration converges the specificity of the three selectors into a narrow band (0.70–0.72), but the recall differences persist: EPS misses 11 of 100 malware samples, the largest-code selector misses 18, and the random selector misses 13.3 On the binaries where EPS and largest-code disagree, largest-code misses eight malware samples that EPS catches, against one in the other direction. This asymmetry is the central lesson of the design experiments. A false positive in the dossier can be resolved downstream, but a binary whose seeds show nothing suspicious gives the agent no lead to follow, and the reporting stage cannot recover what was never read. Under this asymmetry, the seed ranker should maximize recall at acceptable specificity, which is exactly the operating point EPS occupies.

Answer to RQ3: Exploration primarily improves specificity rather than recall: it resolves some false alarms and often uses little of its allowance, but does not consistently recover malware missed during seeding. This supports the recall-oriented seeding choice of RQ2.

Comparison of Models

With the configuration frozen, we ran all eight models once over the 600 locked test binaries. Figure 4 shows how each model distributed its three verdicts over the true-malware and true-benign halves of the split, together with the summary metrics derived from those distributions.

Figure 4. Verdict composition on the locked test set, one row per model sorted by tBA, over (a) the 300 true-malware and (b) the 300 true-benign binaries. Both panels stack the correct verdict first (malicious leftmost in (a), benign in (b)). Each reading is a cut point: strict recall is the malicious segment of (a), and triage recall adds the adjacent suspicious one. The right block reports triage and strict balanced accuracy (tBA, BA) and the coverage and precision of the suspicious queue. Open-weight models are marked †. Short names: Pro/Flash/FL = Gemini 3.1 Pro/3.5 Flash/3.1 Flash-Lite, DSv4 = DeepSeek V4 Pro, G31/G26 = Gemma 4 31B/26B.

Triage operating modes. The models do not converge on a shared behavior and do not split into closed-source and open-weight groups. At the high-specificity end, Gemini 3.1 Pro commits a malicious verdict for 65% of malware while clearing 93.7% of benign samples, the highest strict balanced accuracy (0.805) and tBA (0.855) under the fixed protocol. Gemini 3.5 Flash, GLM 5.2, and Qwen 3.6 27B also occupy comparatively high-specificity operating points. At the high-recall end, Gemma 4 26B commits to a malicious verdict for 88% of malware but reaches only 0.370 specificity, with Gemma 4 31B and Gemini 3.1 Flash-Lite showing similar recall-oriented behavior.4

Neither model provenance nor nominal size explains these operating points. The open-weight GLM 5.2 and closed-source Gemini 3.1 Pro produce the same ternary verdict on 78.3% of test binaries, while similarly sized open-weight models occupy different parts of the recall–specificity spectrum. The highest-scoring open-weight model, GLM 5.2, lies 5.3 tBA points below Gemini 3.1 Pro. The cross-model differences are also substantially larger than the run-to-run variation observed in Section 3.2: repeated runs of one model agree on 91% of the development-split verdicts, while Gemini 3.5 Flash and Gemma 4 26B agree on just 48.2% of the test set.

Suspicious verdict as escalation policy. Figure 5 plots each model’s strict and triage operating points, and comparing the two shows how reinterpreting suspicious verdicts changes recall and specificity. For Gemini 3.1 Pro, including suspicious verdicts raises recall from 0.650 to 0.773 while reducing specificity from 0.960 to 0.937. For DeepSeek V4 Pro, recall rises from 0.603 to 0.967, but specificity falls from 0.790 to 0.333.

Figure 5. Strict and triage operating points on the locked test set. Each model is a segment from its strict verdict (small filled dot) to its triage reading (numbered open circle). Models are numbered 1–8 by tBA as in Figure 4, closed-source blue and open-weight orange.

The suspicious queues also differ substantially in composition. Gemini 3.5 Flash and Gemini 3.1 Pro escalate 12.0% and 7.3% of samples at 87.5% and 84.1% precision, respectively. In contrast, DeepSeek V4 Pro escalates 41.0% of samples at 44.3% precision. The suspicious verdict therefore cannot be interpreted uniformly across models: its frequency and malware enrichment depend strongly on the selected model.

Post-hoc suspicious queue pruning. We examine, post hoc, whether a second model can prune an existing suspicious queue, as depicted in Table 3. Routing Gemini 3.1 Pro’s queue through Gemini 3.5 Flash, the highest-tBA pair among the 56 ordered pairs, shrinks the queue from 44 to 35 samples and raises its precision from 0.841 to 0.943, at the cost of two more missed malware samples. Among open-weight pairs, routing GLM 5.2’s queue through Gemma 4 26B reduces it from 103 to 25 samples and raises precision from 0.602 to 0.840 while missing one additional malware. The overall-best cascade raises tBA by only 0.005, within the observed run-to-run variation. Cascading therefore prunes analyst load at a pair-dependent cost in silent misses rather than improving the classifier.

#SystemBAtBAQueuePrec.Lost
Pro alone.805.85544.841–
1Pro→Flash.808.86035.9432
2Pro→GLM 5.2.815.85729.9312
3Pro→G31.832.85518.8891
4Pro→G26.828.85522.8640
5Pro→DSv4.808.85335.8862
GLM 5.2 alone.767.802103.602–
18GLM 5.2→DSv4.777.80780.6132
19GLM 5.2→G26.775.80325.8401
20GLM 5.2→Qwen 3.6.782.80325.76022
21GLM 5.2→G31.773.80231.7744
24Qwen 3.6→GLM 5.2.767.78825.7601

Table 3. Post-hoc cascades on locked test outputs: top overall and open-weight pairs by tBA, with single-model baselines. Lost is malware cleared by the second model; abbreviations follow Figure 4.

How the budget is spent. The models also differ in how they use the exploration stage, which Table 4 breaks down per model. GLM 5.2, Qwen 3.6 27B, and Gemini 3.1 Pro analyze only 3.6 to 5.4 new functions per sample and stop on their own in 77–90% of runs, while Gemini 3.5 Flash and Gemma 4 26B analyze 9.2 and 14.0 and mostly run their budget out. Target selection styles differ as well: Gemini 3.1 Pro and Qwen 3.6 27B derive about 55% of their targets from their own scratchpad reasoning, Gemma 4 26B follows callees more often (31%), and Gemma 4 31B and DeepSeek V4 Pro lean on prior analysis outputs (about 29%). Despite these styles, all eight models leave the static ranking behind: 35–51% of newly analyzed functions rank outside the top 150 by EPS, and 42–54% are not adjacent to any initial seed. Exploration evidence is frequently used in the final reports. Functions read during exploration are cited in the final report 3.7–7.7× more often than seed functions, as shown in Table 4. This citation frequency measures whether the models use the evidence, not whether the cited conclusions are correct. Reading more is not itself an advantage: the highest-tBA model is among the most frugal and the lowest-tBA model among the most prolific, so there is no monotonic relationship between exploration reads and triage performance under this fixed protocol.

ModelReadsStopScratch.Callees>150Non-adj.Rep.Cited
Pro5.487%56%21%47%46%1.87.7
Flash9.245%39%22%43%54%5.94.1
FL6.286%33%25%43%45%0.07.2
DSv47.131%45%14%35%46%3.64.1
GLM 5.23.690%45%11%43%42%1.45.6
G318.175%30%21%49%47%0.34.8
Qwen 3.64.577%55%11%43%46%0.46.5
G2614.034%33%31%51%48%2.73.7

Table 4. Exploration and reporting behavior. Reads = mean exploration analyses; Stop = explicit done; Scratch./Callees = target-source shares; >150 = outside the EPS top 150; Non-adj. = not adjacent to a seed; Rep. = mean reporting inspections; Cited = explored-to-seed citation-rate ratio. Abbreviations follow Figure 4.

The reporting budget, in contrast, is used sparingly. Six of the eight models take a median of at most one inspection action before committing to a verdict, and no model exhausts the 20-action budget in even 4% of its runs, so the final stage adjudicates the dossier essentially as the earlier stages handed it over.

Answer to RQ4: Under identical evidence and action budgets, the models occupy different recall–specificity and escalation operating points. No model dominates across malware recall, benign clearance, and escalation-queue size, so model selection is itself part of the triage policy.

Discussion and Limitations

Because the models implement different policies under identical evidence, the comparison in Section 4.4 maps operating points under one fixed protocol rather than ranking model quality or fixing a deployment configuration. Per-model tuning could move the individual points.

Quality of the Reports

In addition to the verdict, TRIAGE-CPG produces a structured behavioral report. We assess these reports with an automated proxy judge (Gemini 3.1 Flash-Lite) that compares each against the threat-intelligence evidence derived from VirusTotal for the same sample, returning yes, no, or unknown agreement on the reported malware type, family, capabilities, and role, and flagging over- and under-claiming.5

Figure 6 shows the result on the malware half of the test set. Reported capabilities agree with the external consensus in 75–96% of the cases, the role in 66–83%, and the malware type in 56–76%. Family attribution agrees in only 1–6% of cases, reflecting its dependence on vendor naming and campaign context the static code evidence does not provide. On malware, reports under-claim more often than they over-claim (45–56% vs. 13–22%). On benign samples, over-claiming averages 35% across models and is highest for models that also issue malicious verdicts broadly.

Figure 6. Agreement between report characterizations and external VirusTotal-derived threat-intelligence evidence on the malware half of the locked test set, one group of bars per model, split into closed-source and open-weight groups.

These proxy results indicate that capability- and role-level descriptions agree with the external evidence more consistently than family names, but not that the reports improve analyst decisions or reduce analysis time, which would require a human study.

Limitations of Static Triage

The test-set errors reveal two recurring limitations of the static CPG-based workflow: large binaries and code that hides its relevant behavior behind a wrapper.

Failure modes by file size. Performance becomes less balanced as binary size increases, but the direction of the errors follows each model’s operating point. Under the strict reading, Gemini 3.1 Pro maintains specificity of at least 0.95 across all size quantiles, while its malware recall falls from 0.783 in the smallest quantile to 0.33 in the largest. GLM 5.2 shows a similar pattern: recall falls from 0.733 to 0.350 while specificity remains at least 0.80. The recall-oriented Gemma 4 26B shows the opposite pattern, maintaining recall between 0.80 and 0.95 while its specificity falls from 0.733 to 0.167. Larger binaries therefore amplify the model-specific recall–specificity trade-offs observed in Section 4.4.

Packers, protectors, and installers. Static triage is inherently limited on samples that hide their payload behind a delivery shell such as a packer, protector, or installer, because malicious and benign software then rely on the same mechanisms. We approximate this class with VirusTotal’s Detect-It-Easy results [15], marking such binaries as wrappers. Droppers and loaders have no equally consistent marker in our data, so the resulting wrapper rate is a lower bound. Table 5 reports the wrapper share within each verdict cell.

MalwareBenign
ModelTPSusp.FNTNSusp.FP
Gemini 3.1 Pro12%70%54%33%57%17%
Gemini 3.5 Flash10%57%50%34%56%12%
Gemini 3.1 Flash-Lite27%50%22%20%39%51%
DeepSeek V4 Pro14%54%30%18%37%48%
GLM 5.212%68%46%34%32%23%
Gemma 4 31B23%76%25%12%42%46%
Qwen 3.6 27B20%58%44%31%38%39%
Gemma 4 26B26%66%0%4%24%46%
Mean19%61%44%28%37%44%

Table 5. Wrapper share within each verdict cell. Detect-It-Easy identifies packers, protectors, or installers; the baseline is 29% for malware and 33% for benign samples. Per-cell counts vary, so the mean row is the robust reference.

Wrapped binaries constitute 31% of the test set and occur at similar rates among benign and malicious samples (33% against 29%). They are less common among the correctly flagged malware and cleared benign samples (19% and 28%) but more common among missed malware and false positives (44% each). They are particularly concentrated among escalated malware, of which 61% is wrapped. These results identify wrappers as a shared difficult class for both verdict errors and escalation.

Under the intended triage interpretation, suspicious verdicts on wrapped samples would be routed to unpacking or dynamic analysis. A future unpack-and-re-extract action that constructs a new CPG from the recovered payload could directly address this limitation.

Limitations of the Evaluation

Balanced base rate. The dataset is balanced at 50% malware, which eases per-class comparison but does not reflect operational intake streams where benign samples dominate. Recall, specificity, and TBA are prevalence-independent, but escalation-queue precision is not: at a lower malware prevalence the same verdict behavior would yield queues with substantially lower precision. The reported queue composition should therefore be read as a comparison between models, not a deployment estimate.

Evaluation labels and excluded gray zone. VirusTotal consensus supplies evaluation labels, not definitive ground truth. At dataset-construction time, we required zero VT detections for benign and at least ten for malware. Samples with 1–9 detections were excluded, so we do not characterize binaries on which engines disagree, even though these may be especially relevant to escalation.

Scope of the comparison. The experiments compare LLMs and individual components of TRIAGE-CPG, not the complete workflow against trained static classifiers, commercial detectors, or dynamic-analysis systems. This study addresses the prior question of whether current LLMs can implement a budgeted triage policy from partial static evidence at all, and its ternary verdicts, escalation queues, and behavioral reports have no direct analogue in a classifier score, so a fair comparison requires its own cost-matched design. The results therefore do not establish that LLM-based triage is more accurate or cheaper than simpler alternatives.

Fixed protocol. All models use one configuration selected with Gemini 3.1 Flash-Lite on the development split. The budget values are one operating point, not model-specific optima, and different prompts, budgets, or action interfaces could shift the results, though the shared configuration ensures each model receives the same evidence and actions.

Preprocessing and input scope. The evidence budget excludes decompilation and CPG construction, so we do not measure end-to-end analysis time. The evaluation is conditional on producing a valid CPG, covers only Windows PE binaries, excludes .NET, and neither executes nor unpacks samples, so runtime-only behavior remains outside the workflow. It also assumes non-adversarial inputs: instructions embedded in decompiled code can manipulate LLM analysis agents [7], and we do not evaluate the workflow under such attacks. Finally, the model set reflects Vertex AI availability at experiment time, and serving-side updates may change individual results.

Related Work

Malware analysis. Automated malware analysis has been shaped by sample volume for two decades. Behavior-based systems clustered thousands of daily sandbox reports so that analysts inspect representatives instead of every sample [3], and dynamic analysis remains the backbone of that pipeline [9]. Static approaches face different obstacles. Obfuscation can defeat static detection in principle [28], runtime packing is pervasive among malicious samples [34], and classifiers built on static features degrade once benign programs are packed as well [1], which matches the packed-wrapper failure class of § 5.2. A survey of practitioners reports that analysts use automated results as high-level guidance on where to look and to avoid over-inspecting individual samples [4]. Our study focuses on this bounded first pass and examines how LLMs use partial static-code evidence to clear, flag, or escalate a binary.

Code property graphs. Code property graphs merge the syntax, control flow, and data dependencies of a program into one queryable graph, introduced for vulnerability mining in C code [39] and later generalized into language-independent analysis platforms [20, 36]. Vulnerability discovery on decompiled binaries approaches source-level results in case studies [24], although decompiler evaluations show the recovered code carries semantic errors and template-like artifacts [5], noise that any consumer of a CPG inherits. LLMxCPG uses CPG-guided slicing to fit vulnerability-relevant code into an LLM context [22]. Our workflow instead uses the function-level call graph primarily as a navigation interface for selecting a bounded number of function reads during malware triage.

Graph signals and function prioritization. Scoring call-graph nodes with inexpensive structural signals has a long record in malware detection: PageRank has been used for malware categorization [17], and MalScan classifies Android apps from centrality vectors of sensitive APIs over the call graph [37]. A second line of work ranks code units for human review rather than classifying whole samples: MKLDroid assigns malice scores down to basic blocks and methods [30], Genius ranks binary functions for manual confirmation effort [11], and DeepReflect localizes potentially malicious functionality to reduce reverse-engineering effort [8]. In contrast, EPS is an untrained ranking over three static signals that gives every evaluated LLM the same initial function set, which we compare with several inexpensive alternatives without claiming optimality.

LLMs for code and malware analysis. LLMs increasingly support binary-code analysis, including decompilation [33, 35], malware summarization [23], Android malware from code slices [31], and malicious-code localization [32]. Most closely, TTPDetect retrieves candidate functions and incrementally explores call-graph context to attribute ATT&CK techniques in stripped malware binaries [38]. Our study addresses a different decision: given both benign and malicious binaries and a fixed function-read budget, how do different LLMs choose among clearing, flagging, and escalating a sample? Recent work also demonstrates that instructions embedded in decompiled code can manipulate LLM-based reverse-engineering agents [7].

Triage with a reject option. Letting a classifier reject uncertain inputs goes back to Chow’s error–reject tradeoff [6], developed further as selective classification [12], learning to defer to a human expert [29], and cost-sensitive learning that prices the error directions independently [10]. A separate budgeted line acquires costly features sequentially and stops once the evidence suffices [16]. Security operations already run on this logic, as alert-triage systems suppress or escalate alerts to protect analyst attention [14]. Our setting instantiates feature acquisition with function reads as the unit of cost and interprets rejection as escalation.

Conclusion

We studied how current LLMs triage a decompiled binary from a small, graph-selected subset of its functions, using TRIAGE-CPG as a common evidence interface combining LLM-free seed selection, bounded call-graph exploration, and a ternary verdict. Across eight models under one protocol, the highest-scoring model reaches a strict balanced accuracy of 0.805 and a tBA of 0.855 while inspecting about 40 of a mean 1,000 recovered functions per binary. The larger finding is that models occupy substantially different recall–specificity and escalation operating points, spanning both closed-source and open-weight families, so model choice itself determines the triage policy. These results characterize LLM behavior under limited static evidence rather than establishing superiority over conventional malware detectors. Future work should benchmark the complete workflow against non-LLM detection baselines and connect the escalation queue with unpacking or dynamic analysis, where wrapped samples concentrate.

References

A Function Selection and EPS Weights

Table 6 reports the fixed-seed-count sweep across binary-size classes that motivates the proportional seeding rule of § 4.2.

Binary sizenn10255075100150
Small (<100)630.8190.7950.7320.7660.7870.787
Mid (100–750)680.5600.8210.8150.7780.7410.692
Large (>750)690.6390.7230.7120.6860.7300.670
All2000.6900.8100.7750.7550.7500.720

Table 6. Development-split balanced accuracy by binary size and fixed seed count (exploration off). Bold marks each size class’s best count.

EPS weight selection. We sweep all 70 EPS weight vectors with components drawn from {0, 0.25, 0.5, 0.75, 1} summing to one on the train split, scored under the strict verdict metric. The best vector places weight 0.50 on the boundary flag (BB) and 0.25 each on reverse PageRank and code length, reaching 0.720 balanced accuracy and 0.756 F1, with the three runner-up configurations scoring between 0.690 and 0.710. The deployed vector assigns zero weight to forward PageRank and the API-rarity flag. We deploy the train-best vector and freeze it for every later experiment.

B Exploration

Table 7 gives the per-configuration detail behind the exploration experiments of § 4.3: the paired on/off comparison, agent-guided against random targeting, and the seed selectors rerun under the full pipeline. For the matched-action random control in panel (b), we set the exploration cap to 13, rounding the agent’s mean of 13.2 exploration actions. Because agent actions may query the graph while random actions always analyze a function, matching actions does not imply matching function reads (5.2 vs. 11.3).

C Open Science

The accompanying artifact contains the TRIAGE-CPG implementation, benchmark manifests with SHA-256 hashes, labels, and split assignments for all 1,000 binaries, frozen experiment configurations, aggregate artifacts underlying all reported analyses, sanitized per-sample behavioral reports and VirusTotal-derived judgments for the eight locked test runs, and the corresponding analysis scripts. The artifact is available at https://doi.org/10.5281/zenodo.22771897. The binaries originate from VirusTotal and cannot be redistributed under its terms of service. We publish their hashes so VirusTotal subscribers can retrieve the same samples, subject to access and continued availability, together with the CPG extraction configuration required to reconstruct the graphs.

Reporting budget2575150
105 / −36 / −213 / −6
204 / −110 / 010 / −3
301 / −45 / −214 / −2

Table 7. Development-split exploration analyses under the strict verdict. (a) Net benign/malware binaries corrected minus hurt by enabling exploration across nine seed/reporting configurations; bold marks the deployed configuration. (b) Agent-guided and random targeting under full and action-matched budgets, reporting realized function reads and balanced-accuracy ranges. (c) Seed-selector performance under the full pipeline.

PolicyArmsReadsBal. Acc.
Agent-guided55.20.800–0.820
Random, full budget325.40.775–0.805
Random, action-matched311.30.760–0.815

Table 7. Exploration policy

SelectorRecallSpec.Bal. Acc.
EPS0.8900.7100.800
Largest code0.8200.7000.760
Random0.8700.7200.795

Table 7. Seed selector, full pipeline

D Ethical Considerations

This work analyzes existing Windows malware obtained from VirusTotal and creates no new malware, exploit code, or attack tooling. The pipeline never executes the samples, and the binaries are not redistributed. The generated reports describe behavior at the level of standard threat-intelligence write-ups and omit decompiled function bodies and instructions for building or improving malware. The intended and evaluated use is defensive, reducing the triage load of security analysts, and the paper documents the failure modes an operator must account for before relying on the system. No human subjects or personal data are involved.

Use of Generative AI

Pi (pi.dev), an agentic coding harness, was used with on-premises language models and models provided by Anthropic and OpenAI to assist with developing parts of the experimental code and analysis scripts and with editing and polishing the manuscript. The authors manually reviewed all AI-assisted code and text before inclusion. The research questions, system design, experimental protocol, and interpretation of the results were determined by the authors, who take full responsibility for the paper.

References

  1. [1]Hojjat Aghakhani, Fabio Gritti, Francesco Mecca, Martina Lindorfer, Stefano Ortolani, Davide Balzarotti, Giovanni Vigna, and Christopher Kruegel. 2020. When Malware Is Packin’ Heat; Limits of Machine Learning Classifiers Based on Static Analysis Features. In Network and Distributed System Security Symposium (NDSS).
  2. [2]Michael Bailey, Jon Oberheide, Jon Andersen, Z. Morley Mao, Farnam Jahanian, and Jose Nazario. 2007. Automated Classification and Analysis of Internet Malware. 178–197. doi:10.1007/978-3-540-74320-0_10DOI
  3. [3]Ulrich Bayer, Paolo Milani Comparetti, Clemens Hlauschek, Christopher Kruegel, and Engin Kirda. 2009. Scalable, Behavior-Based Malware Clustering. In Network and Distributed System Security Symposium (NDSS).
  4. [4]Marcus Botacin. 2024. What Do Malware Analysts Want from Academia? A Survey on the State of the Practice to Guide Research Developments. In International Symposium on Research in Attacks, Intrusions and Defenses (RAID).DOI
  5. [5]Ying Cao, Runze Zhang, Ruiging Liang, and Kai Chen. 2024. Evaluating the Effectiveness of Decompilers. In ACM International Symposium on Software Testing and Analysis (ISSTA).DOI
  6. [6]C. K. Chow. 1970. On Optimum Recognition Error and Reject Tradeoff. IEEE Transactions on Information Theory 16, 1 (1970), 41–46. doi:10.1109/TIT.1970.1054406DOI
  7. [7]Brian Crawford, Justin Phillips, and Patrick McClure. 2026. Automatically Attacking Software Reverse Engineering AI Agents. European Conference on Cyber Warfare and Security 25, 1 (2026), 199–205. doi:10.34190/eccws.25.1.4597DOI
  8. [8]Evan Downing, Yisroel Mirsky, Kyuhong Park, and Wenke Lee. 2021. DeepReflect: Discovering Malicious Functionality Through Binary Reconstruction. In USENIX Security Symposium.
  9. [9]Manuel Egele, Theodoros Scholte, Engin Kirda, and Christopher Kruegel. 2012. A Survey on Automated Dynamic Malware-Analysis Techniques and Tools. Comput. Surveys 44, 2 (2012), 6:1–6:42. doi:10.1145/2089125.2089126
  10. [10]Charles Elkan. 2001. The Foundations of Cost-Sensitive Learning. In International Joint Conference on Artificial Intelligence (IJCAI).
  11. [11]Qian Feng, Rundong Zhou, Chengcheng Xu, Yao Cheng, Brian Testa, and Heng Yin. 2016. Scalable Graph-Based Bug Search for Firmware Images. In ACM Conference on Computer and Communications Security (CCS).DOI
  12. [12]Yonatan Geifman and Ran El-Yaniv. 2017. Selective Classification for Deep Neural Networks. In Advances in Neural Information Processing Systems (NeurIPS).arxiv.org/abs/1705.08500
  13. [13]Mariano Graziano, Davide Canali, Leyla Bilge, Andrea Lanzí, and Davide Balzarotti. 2015. Needles in a Haystack: Mining Information from Public Dynamic Analysis Sandboxes for Malware Intelligence. In USENIX Security Symposium.
  14. [14]Wajih Ul Hassan, Shengjian Guo, Ding Li, Zhenghang Chen, Kangke Joee, Zhichun Li, and Adam Bates. 2019. NoDoze: Combatting Threat Alert Fatigue with Automated Provenance Triage. In Network and Distributed System Security Symposium (NDSS).DOI
  15. [15]horsicq. 2014. Detect It Easy (DiE). https://github.com/horsicq/Detect-It-Easy accessed 2026-07-09.
  16. [16]Shihao Ji and Lawrence Carin. 2007. Cost-Sensitive Feature Acquisition and Classification. Pattern Recognition 40, 5 (2007), 1474–1485. doi:10.1016/j.patcog.2006.11.008
  17. [17]BooJoong Kang, Suleiman Yerima, Kieran McLaughlin, and Sakir Sezer. 2015. PageRank in Malware Categorization. In Conference on Research in Adaptive and Convergent Systems (RACS).DOI
  18. [18]Dhihuling Kirat, Giovanni Vigna, and Christopher Kruegel. 2014. BareCloud: Bare-Metal Analysis-Based Evasive Malware Detection. In USENIX Security Symposium.
  19. [19]Clemens Kolbitsch, Engin Kirda, and Christopher Kruegel. 2011. The Power of Procrastination: Detection and Mitigation of Execution-Stalling Malicious Code. In ACM Conference on Computer and Communications Security (CCS).
  20. [20]Alexander K"uchler and Christian Banse. 2022. Representing LLVM-IR in a Code Property Graph. 360–380. doi:10.1007/978-3-031-22390-7_21DOI
  21. [21]Alexander K"uchler, Alessandro Mantovani, Yufei Han, Leyla Bilge, and Davide Balzarotti. 2021. Does Every Second Count? Time-Based Evolution of Malware Behavior in Sandboxes. In Network and Distributed System Security Symposium (NDSS).DOI
  22. [22]Ahmed Lekssays, Hamza Mouhcine, Khang Tran, Ting Yu, and Issa Khalil. 2025. LLMxCPG: Context-Aware Vulnerability Detection Through Code Property Graph-Guided Large Language Models. In USENIX Security Symposium.
  23. [23]Haolang Lu, Hongrui Peng, Guoshun Han, Jiaoyuan Cui, Cheng Wang, Weifei Jin, Songtao Wang, Shengli Pan, and Xiaofeng Tao. 2025. Malsight: Exploring Malicious Source Code and Benign Pseudocode for Iterative Binary Malware Summarization. IEEE Transactions on Information Forensics and Security 20 (2025), 6733–6747. doi:10.1109/TIFS.2025.3583552
  24. [24]Alessandro Mantovani, Luca Cosgampa, Yan Shoshitaishvili, and Davide Balzarotti. 2022. The Convergence of Source Code and Binary Vulnerability Discovery—A Case Study. In ACM Asia Conference on Computer and Communications Security (AsiaCCS).DOI
  25. [25]Andrea Marcelli, Mariano Graziano, Xavier Ugarte-Pedrero, Yanick Fratantonio, Mohamad Mansouri, and Davide Balzarotti. 2022. How Machine Learning Is Solving the Binary Function Similarity Problem. In USENIX Security Symposium.
  26. [26]Najmeh Mirmirkhani, Mahathi Priya Appini, Nick Nikiforakis, and Michalis Polychronakis. 2017. Spotless Sandboxes: Evading Malware Analysis Systems Using Wear-and-Tear Artifacts. In IEEE Symposium on Security and Privacy (SP).
  27. [27]Mahmoud Mohammadi, Yipeng Li, Jane Lo, and Wendy Yip. 2025. Evaluation and Benchmarking of LLM Agents: A Survey. In ACM SIGKDD Conference on Knowledge Discovery and Data Mining (KDD).DOI
  28. [28]Andreas Moser, Christopher Kruegel, and Engin Kirda. 2007. Limits of Static Analysis for Malware Detection. In Annual Computer Security Applications Conference (ACSAC).
  29. [29]Hussein Mozannar and David Sontag. 2020. Consistent Estimators for Learning to Defer to an Expert. In International Conference on Machine Learning (ICML).
  30. [30]Annamalai Narayanan, Hanxi Chen, Andriy Madan, Lihui Chen, and Yang Liu. 2018. A Multi-View Context-Aware Approach to Android Malware Detection and Malicious Code Localization. Empirical Software Engineering 23, 3 (2018), 1222–1274. doi:10.1007/s10664-017-9539-8DOI
  31. [31]Xingzhi Qian, Xinran Zheng, Yiling He, Shuo Yang, and Lorenzo Cavallaro. 2025. LAMD: Context-Driven Android Malware Detection and Classification with LLMs. In IEEE Security and Privacy Workshops (SPW).arxiv.org/abs/2502.13055
  32. [32]Tiezhu Sun, Marco Alecci, Aleksandr Pilgun, Yewon Song, Xunzhu Tang, Jordan Samhi, Tegawendé F Bissyané, and Jacques Klein. 2025. MalloC: Toward Fine-Grained Android Malicious Payload Localization via LLMs. In IEEE International Conference on Software Maintenance and Evolution (ICSME).
  33. [33]Hanzhou Tuan, Qi Luo, Jing Li, and Yuqun Zhang. 2022. LLM4Decompile: Decompiling Binary Code with Large Language Models. In Conference on Empirical Methods in Natural Language Processing (EMNLP).
  34. [34]Xabier Ugarte-Pedrero, Davide Balzarotti, Igor Santos, and Pablo G. Bringas. 2015. SoK: Deep Packer Inspection: A Longitudinal Study of the Complexity of Run-Time Packers. In IEEE Symposium on Security and Privacy (SP).
  35. [35]Yuanchao Wang, Ye Tian, Hongmei Wei, and Fei Wang. 2026. Large Language Models for Binary Code Decompilation: Paradigms, Evaluation, and Challenges. In International Conference on Computer Network Security and Software Engineering (CNSSE).DOI
  36. [36]Konrad Weiss and Christian Banse. 2022. A Language-Independent Analysis Platform for Source Code. doi:10.48550/arXiv.2203.08424 arXiv:2203.08424; preprint.
  37. [37]Yueming Wu, Xiaodi Li, Deqing Zou, Wei Yang, Xin Zhang, and Hai Jin. 2019. MalScan: Fast Market-Wide Mobile Malware Scanning by Social-Network Centrality Analysis. In IEEE/ACM International Conference on Automated Software Engineering (ASE).DOI
  38. [38]Zhou Xuan, Xianghe Xu, Mingwei Zheng, Louis Zheng-Hua Tan, Jinyao Guo, Tiantai Zhang, Le Yu, Chengpeng Wang, and Xiangyu Zhang. 2026. Identifying Adversary Tactics and Techniques in Malware Binaries with an LLM Agent. doi:10.48550/arXiv.2602.06325 arXiv:2602.06325; preprint.DOI
  39. [39]Fabian Yamaguchi, Nico Golde, Daniel Arp, and Konrad Rieck. 2014. Modeling and Discovering Vulnerabilities with Code Property Graphs. In IEEE Symposium on Security and Privacy (SP).
  40. [40]John Yang, Carlos E. Jimenez, Alexander Wettig, Kilian Lieret, Shunyu Yao, Karthik Narasimhan, and Ofir Press. 2024. SWE-agent: Agent-Computer Interfaces Enable Automated Software Engineering. In Advances in Neural Information Processing Systems (NeurIPS).arxiv.org/abs/2405.15793

Paper details

vlnc:W_t4s4audy
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

Pi (pi.dev)

View statement
Looking for related papers…
Contents