acceptodds
Under review as a conference paper at ICLR 2027

LARA: Verifier-Guided Rule-Level Semantic Fuzzing for Auditing Local Agent Runtimes

Abstract

Local LLM agents mediate between partially trusted inputs and privileged host actions through runtime code. Historical fixes reveal failures in this mediation, but their code-level forms are project-specific. We present LARA (Local Agent Runtime Auditor), which formulates security-rule synthesis as verifier-guided, rule-level semantic fuzzing: semantic rules replace grammar-generated inputs; applicability and validity reasoning drive residual-conditioned CULL, MODIFY, and AUGMENT mutations rather than fixed operators; and vulnerable/fixed execution feeds new rounds until semantic saturation or the round budget is exhausted. Accepted rules are grounded in a runtime and executed as CodeQL queries. On 275 OpenClaw construction cases, this search raises Patch Recall from 61.1% to 81.5% and patch-discriminating Success from 61.1% to 80.0%; an ablation attributes 49 of the 52 additional successful cases to semantic rule revision rather than query-only refinement. Before target vulnerability feedback, adapted rules localize 17/22 Nanobot and 9/12 Hermes repairs, but discriminate only 5/22 and 4/12, respectively. Refinement on each target’s historical cases raises Success to 15/22 and 7/12. Separately, review of frozen-corpus findings on four latest snapshots produced 25 previously unreported vulnerability candidates validated by proof-of-concept (PoC) exploits. These results suggest that reusable security rules from historical fixes can bootstrap the auditing of new local agent runtimes, for which target-agent-specific evidence and rule adaptation is essential.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
Local LLM Agents, Static Analysis

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_CtJMOpenReview ↗
Rating
2
Confidence
2
Informativeness
1
Presentation
1
Soundness
1
Read review
Paper summary

LLM agents typically have direct access to shell, file system, browser, and credentials, so it is very important to ensure agent safety. This paper targets agent runtime, and proposes LARA, which aims to synthesize security rules from historical vulnerability fixes to audit local LLM agent runtimes. More specifically, LARA iteratively revises these rules using feedback from CodeQL analysis on vulnerable and fixed revisions, and then adapts them across runtimes. Experimental results show improved detection on construction and refinement cases and 25 previously unreported vulnerability candidates supported by manually executed PoCs.

Critical strengths

The paper targets the timely and important problem of agent safety. It is also great to see this paper target the agent runtime. The idea of leveraging historical vulnerability fixes to audit local LLM agent runtimes is also interesting and can be promising.

The experimental study has been performed on real-world agent systems, including OpenClaw, Hermes, and Nanobot. Moreover, 25 previously unreported vulnerability candidates have been produced with PoC support.

Critical weaknesses

Overall, I feel the paper presentation shall be further improved in the following ways:

  • It is not quite clear to me why the term “fuzzing” is used while the paper is mostly just about “mutation”. “Fuzzing” and “semantic fuzzing” have different meanings in the software literature, and the current presentation can be a bit confusing.

  • The related work section is a bit too brief, and shalle be further augmented.

  • The approach is a bit hard to follow, and some concrete code examples would definitely help there.

  • The experimental setup is also not well justified and explained. For example, it is not quite clear what cases are used for learning and evaluation.

  • How much human effort was required to identify the 25 PoC-supported candidates, and how does this compare with auditing with existing tools or LLMs without LARA? How many of the candidates have been confirmed or commented by the agent developers?

Questions for authors

Pls see the questions in the weaknesses part.

2 comments
AuthorsOpenReview ↗

Response to the Concern About Semantic Fuzzing and Evaluation

Thank you for the comments. We would like to clarify the role of semantic fuzzing and share some additional results.

LARA fuzzes security rules rather than program inputs. It adds or modifies rules based on vulnerabilities missed in previous rounds, translates them into CodeQL queries, and uses the validation results to guide further changes. We work at the semantic level because the same security problem can appear in different code implementations. Instead of directly changing a query to match a particular code pattern, LARA first modifies the security requirement that the query checks.

To examine whether this semantic layer is useful, we added SharedQL, a baseline that directly adds, modifies, or removes CodeQL queries in a shared library using feedback from historical vulnerabilities. Both approaches can use previous results to improve their rules or queries. The main difference is that SharedQL works directly with CodeQL queries, while LARA first works with semantic security rules. Directly modifying queries may make it easier to cover the specific vulnerabilities seen during development, but this does not necessarily lead to better detection of unseen vulnerabilities with different implementations.

We evaluated both approaches using 275 development vulnerabilities and 117 held-out test vulnerabilities. The held-out cases were not used for rule refinement. The results are as follows:

MetricLARASharedQL
DEV Patch Recall81.5%90.9%
Held-out TEST Recall47.0% (55/117)40.2% (47/117)
AuthorsOpenReview ↗

Complete Response to Reviewer Comments

Thank you for the comments. We would like to clarify the role of semantic fuzzing and share some additional results addressing the reviewer's concerns.

Semantic Fuzzing and the Semantic-Rule Layer

LARA fuzzes security rules rather than program inputs. It adds, modifies, or removes semantic rules based on vulnerabilities missed in previous rounds, translates the resulting rules into CodeQL queries, and uses validation feedback to guide further refinement.

We work at the semantic level because the same security problem can appear in different code implementations. Rather than directly modifying a query to match a particular code pattern, LARA first modifies the underlying security requirement that the query checks.

To examine whether this semantic layer is useful, we introduced SharedQL, a baseline that directly adds, modifies, or removes CodeQL queries in a shared library using feedback from historical vulnerabilities.

Both approaches can use previous results to improve their rules or queries. The main difference is that SharedQL works directly with CodeQL queries, while LARA first works with semantic security rules.

Direct query modification can achieve better coverage of previously seen cases, but this does not necessarily lead to better detection of unseen vulnerabilities with different implementations.

We evaluated both approaches on 275 development vulnerabilities and 117 held-out test vulnerabilities. The held-out cases were not used for rule refinement, and the final rule and query corpora were frozen before testing.

MetricLARASharedQL
DEV Patch Recall81.5%90.9%
Held-out TEST Recall47.0% (55/117)40.2% (47/117)

Human Effort per Validated Finding

We agree that human effort should be reported and will add an "Auditing Cost" paragraph.

The approximately 93,000 Hermes findings were first deduplicated into root causes, rather than reviewed individually. We manually screened 270 sampled root causes from Hermes and 1,035 across four projects, identifying 66 potential candidates (6.38%; 90% Wilson CI: 5.24–7.74%). Of these, 32 entered confirmation review and 31 had executed PoCs, resulting in 25 validated findings and six falsified candidates. We also reviewed an additional set of 501 root causes, which will be reported separately.

Agent assistance reduced the manual effort required for screening and PoC development. Many findings could be excluded immediately because they were located in test files or did not involve security-relevant behavior. We estimate approximately 4 hours for initial screening, 7 hours for detailed review, and 3 hours for PoC authoring and validation, or 14 person-hours for the sampled screening and confirmation process.

We will clarify that the 6.38% screening yield is not alert precision, the 25 validated findings do not represent a per-project rate, and we do not claim overall auditing-efficiency superiority.

Comparison with Existing Tools and LLM-Only Auditing

We agree that the paper should distinguish vulnerability localization from end-to-end auditing. Section 7 already describes LARA as a producer of review locations, and we will make this scope clearer in the abstract and conclusion.

On the 275 development repairs, stock Semgrep and CodeQL rules achieved only 1.8% and 0.4% Success, respectively (Table 4), indicating limited coverage of the runtime-specific failure classes studied in this paper.

LARA already uses an LLM during triage. We therefore agree that a rule-guided versus unguided LLM review comparison would be more informative than treating LARA and LLM auditing as entirely separate approaches. We will clarify the scope of our existing comparisons without claiming an end-to-end advantage that has not been measured.

Developer Confirmation and Finding Provenance

We will extend Tables 7–8 with the rule ID responsible for each finding, its origin (random sample or targeted review), and its disclosure status.

As of November 18, 2026, all 25 findings have been reported, and two have been acknowledged by the respective developers. Findings 15–25 on OpenHands were produced from the unchanged Nanobot rule corpus, and we will explicitly identify the corresponding rules to document their provenance.

Reviewer_snBfOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper presents LARA, which formulates security-rule synthesis as verifier-guided, rule-level semantic fuzzing. LARA searches over a shared corpus of semantic security requirements, separating these requirements from runtime-specific bindings and executable queries. Its main contribution is a verifier-guided procedure for revising and transferring this corpus.

Critical strengths
  1. Important research topic: The paper examines the runtime code connecting agent inputs to privileged host actions.

  2. Useful ablation of rule revision: On the 275 construction cases, full LARA gains 52 successful cases over initialization, while refinement with frozen semantic rules gains only three.

  3. The paper reports 25 PoC-supported vulnerability candidates across four runtimes. These findings provide some evidence that the generated rules can guide investigation beyond the historical construction cases.

Critical weaknesses
  1. Limited methodological novelty: LARA adds an explicit semantic-rule layer and shared-corpus management, but the proposed main workflow is close to QLCoder, including the generating queries, executing them on vulnerable and fixed code, and revising them using feedback. The paper does not sufficiently demonstrate what new capability these additions provide over the extending existing system.

  2. The benefit of the explicit semantic-rule layer remains unclear. LARA constructs and refines a shared rule corpus using feedback across all construction cases and existing security rules, while QLCoder synthesizes queries from individual vulnerability/fix pairs. Thus, the reported performance gap does not isolate the benefit of LARA's semantic-rule representation. It could be due to the cross-case information sharing. Therefore, the paper lacks a baseline that can freely refine a shared query library using the same evidence, model, and computational budget.

  3. Unclear auditing efficiency: The 25 PoC-supported vulnerability candidates are valuable, but their discovery involved screening a large volume of findings, including approximately 93,000 for Hermes. Only 6.38% of randomly sampled root causes were classified as potential security candidates. This screening yield does not establish overall alert precision. In addition, the human effort required per validated finding is not reported. It therefore remains unclear how much LARA improves auditing efficiency.

  4. Unestablished benefit of cross-runtime transfer. As shown in RQ2 results, on Hermes, vulnerable and fixed finding sets are nearly identical, and only one of four successful cases is attributed to meaningful transfer. This suggests that the transferred rules often locate relevant code but struggle to distinguish vulnerable code from fixed versions. To demonstrate that transfer improves effectiveness or reduces adaptation effort, the paper needs to compare against directly building rules from scratch on the target runtime.

Questions for authors
  1. What can the explicit semantic-rule layer do, while directly refining a shared CodeQL query library cannot?

  2. Does transferring the source corpus outperform building rules from scratch on the target runtime?

  3. How much human effort was required to obtain the 25 PoC-supported candidates?

  4. How well do frozen rules perform on unseen vulnerabilities?

6 comments
AuthorsOpenReview ↗

Response to the Question on Frozen Rules' Generalization to Unseen Vulnerabilities (Question #4)

We thank the reviewer for raising this question. To evaluate the generalization of LARA's frozen rules, we conducted an additional experiment on 117 held-out OpenClaw vulnerability advisories that were excluded from rule synthesis and refinement.

ApproachDetected VulnerabilitiesRecall
LARA (Ours)55 / 11747.0%
QLCoder25 / 11721.4%
CodeQL2 / 1171.7%
Semgrep5 / 1174.3%

LARA achieves 47.0% recall, compared to 21.4% for QLCoder, 1.7% for CodeQL, and 4.3% for Semgrep. This corresponds to a 2.20× improvement over the strongest baseline and provides evidence that the frozen rules remain effective on vulnerabilities not seen during development.

Thank you for adding the evaluation on 117 held-out OpenClaw advisories.

Could you clarify the protocol behind this result? In particular, how were the held-out advisories selected and checked for overlap with the construction vulnerabilities, what rule/query corpus was frozen for each method, and what counts as a detected vulnerability? The original evaluation distinguishes patch localization from discrimination between vulnerable and fixed code. Please state whether the new recall requires that discrimination, and report it separately if the new detection criterion is different.

The additional experiment does not yet resolve the other main questions in my review:

  • The comparison with QLCoder does not isolate the semantic-rule representation from cross-case information sharing. A shared query-library baseline with the same evidence, model, and refinement budget would clarify that contribution; otherwise, the attribution should be qualified.
  • The benefit of cross-runtime transfer still needs a target-from-scratch comparison, including effectiveness and adaptation effort under comparable resources.
  • The auditing-efficiency claim needs the human triage and validation effort behind the 25 PoC-supported candidates, with the screening stages and their denominators distinguished.
AuthorsOpenReview ↗

Response to the Follow-up on Held-out Evaluation and Semantic Rules

Thank you for the follow-up. We would like to clarify the evaluation setup and share the results of an additional experiment.

We collected 392 verified OpenClaw vulnerabilities, of which 275 were used for rule development and the remaining 117 were reserved for testing. We checked that there were no overlapping vulnerabilities or fixing commits between the two sets. The test cases were not used for rule construction or refinement.

For the held-out test, we used LARA's final semantic-rule corpus and its generated CodeQL queries, as well as SharedQL's final query library. Both were frozen after development, with no further changes based on the test results. We follow the vulnerability detection recall criterion used in prior static analysis studies (Lipp et al., ISSTA 2022). A vulnerability is counted as detected if at least one alert is reported in a patch-related file of the vulnerable version. This criterion does not require the alert to disappear in the fixed version.

We also added SharedQL to examine whether LARA's improvement comes from the semantic-rule layer or simply from sharing information across vulnerabilities. SharedQL uses historical vulnerability feedback to directly add, modify, or remove CodeQL queries in a shared library, without using semantic rules. This allows both approaches to share knowledge across cases, while differing in how they modify their detection rules.

Directly modifying CodeQL queries can make it easier to cover the specific vulnerable code patterns seen during development. However, higher recall on known cases does not necessarily mean better detection of unseen vulnerabilities. LARA instead modifies the underlying security requirements before generating queries, which may help detect similar security problems in different implementations.

We evaluated both approaches on the development and held-out test sets. The results are shown below.

MetricLARASharedQL
DEV Patch Recall81.5%90.9%
Held-out TEST Recall47.0% (55/117)40.2% (47/117)
Reviewer_BcAYOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

This paper presents LARA, a verifier-guided, rule-level semantic fuzzing framework for auditing local LLM-agent runtimes. The key idea is to treat semantic security rules, rather than concrete program inputs, as the objects of fuzzing. LARA extracts reusable security rules from historical vulnerability-fix pairs, adapts these rules to new agent runtimes, grounds them into executable CodeQL queries, and iteratively refines them using residual feedback from vulnerable and fixed versions. The paper evaluates LARA on several local agent runtimes, including OpenClaw, Nanobot, Hermes, and OpenHands. The results indicate that semantic rule refinement improves patch recall and patch discrimination on OpenClaw construction cases.

Critical strengths

Important and timely problem The paper focuses on the runtime layer of local LLM agents, which is complementary to existing work on prompt injection, malicious skills, tool poisoning, and model-level attacks. This is a valuable perspective because the final security consequence often depends on runtime code that translates model outputs into privileged system actions. Interesting abstraction of security rules Separating a reusable semantic requirement from its target-specific implementation binding is a reasonable and potentially useful design choice. For example, the same requirement that a privileged effect must be protected by an authorization relation may be implemented using different APIs, function names, and data structures across different runtimes.

Critical weaknesses

Lack of independent held-out evaluation: the main performance results primarily reflect construction-set fitting. The headline results reported in the abstract—81.5% Patch Recall and 80.0% Success ([L16–L18])—are obtained entirely from 275 OpenClaw construction cases. They are not supported by an independent held-out test set. Lack of sufficient support for the central claim that security requirements remain invariant across runtimes. One of the paper’s central theoretical claims is that security requirements remain invariant across different runtimes and that cross-project transfer mainly requires rebinding symbols to target-specific program entities. However, the experimental results do not support this claim. Only 22.2% of the rules in Nanobot (40/180) and 12.8% of the rules in Hermes (23/180) preserve their original form. The vast majority of rules require MODIFY operations. Lack of reliable causal attribution for the 25 PoC findings on recent snapshots and potential overstatement of the results. The paper reports 25 PoC-validated vulnerability candidates in recent snapshots of the evaluated projects. However, Tables 7 and 8 do not provide the specific rule ID associated with each finding, nor do they establish whether each vulnerability was actually discovered as a result of an LARA-generated or LARA-refined rule.

Questions for authors

Evaluation and Generalization: Can the authors provide an independent held-out evaluation, such as leave-one-vulnerability-out or leave-one-project-out testing, to demonstrate that the reported gains generalize beyond the OpenClaw construction cases? Cross-Runtime Transfer: Given that most rules require substantial modification when transferred to Nanobot and Hermes, how do the authors justify the claim that the underlying security requirements remain invariant across runtimes? Please compare against a Target-from-Scratch baseline. Attribution and Validation: For each of the 25 reported PoC findings, can the authors provide the corresponding LARA rule, the complete discovery provenance, and the disclosure or confirmation status from the relevant stakeholders?

3 comments
AuthorsOpenReview ↗

Response to the Concern About the Lack of Independent Held-out Evaluation (Critical Weakness #1 and Question #1)

We thank the reviewer for pointing out the lack of independent held-out evaluation. To address this concern, we conducted an additional experiment on 117 held-out OpenClaw vulnerability advisories that were not used during rule synthesis or refinement. We evaluated LARA and three baselines on the same benchmark, with the results summarized below.

ApproachDetected VulnerabilitiesRecall
LARA (Ours)55 / 11747.0%
QLCoder25 / 11721.4%
CodeQL2 / 1171.7%
Semgrep5 / 1174.3%

LARA detects 55 vulnerabilities (47.0%), compared to 25 (21.4%) for QLCoder, the strongest baseline, representing a 25.6 percentage-point improvement. These results provide additional evidence that LARA's rules can detect vulnerabilities beyond those used during construction.

Thnaks for your update.

AuthorsOpenReview ↗

Complete Response to Reviewer Comments

Held-out Evaluation (Critical Weakness #1 and Question #1)

We thank the reviewer for pointing out the lack of independent held-out evaluation. To address this concern, we conducted an additional experiment on 117 held-out OpenClaw vulnerability advisories that were not used during rule synthesis or refinement.

We collected 392 verified vulnerabilities, using 275 for rule development and reserving 117 for testing. We checked that the two sets contained no overlapping vulnerabilities or fixing commits. We then evaluated LARA and three baselines on the same held-out set, using their frozen rules without further refinement.

ApproachDetected VulnerabilitiesRecall
LARA (Ours)55/11747.0%
QLCoder25/11721.4%
CodeQL2/1171.7%
Semgrep5/1174.3%

LARA detects 55 vulnerabilities, compared with 25 for QLCoder, the strongest baseline, representing a 25.6 percentage-point improvement. These results provide additional evidence that LARA's rules can detect vulnerabilities beyond those used during their construction.

Developer Confirmation and Provenance

We will add the LARA rule ID, finding origin (random sample or targeted review), and disclosure status to Tables 7–8. As of November 18, 2026, all 25 findings have been reported to the respective developers, and two have been acknowledged.

Findings 15–25 on OpenHands were produced using the unchanged Nanobot rule corpus. We will explicitly identify the corresponding rules to make this transfer provenance clear.

Cross-Runtime Transfer

We also conducted an experiment to examine whether transferring semantic rules from OpenClaw provides an advantage over constructing rules directly on a new agent runtime.

We compared three settings:

  • LARA-Transfer R0: We started with the 180 semantic rules learned from OpenClaw and adapted them to the target runtime using only its source code and architecture. We generated and validated the corresponding CodeQL queries without using target-specific historical vulnerabilities or patches.
  • LARA-Transfer + Refine: Starting from the adapted R0 rules, we used historical vulnerabilities from the target runtime to identify missed cases and further refine the semantic rules. We then regenerated and validated the corresponding queries.
  • LARA-Target-Scratch: We excluded the OpenClaw-derived rules and started with generic security knowledge. Using the target source code and the same historical training vulnerabilities as Transfer + Refine, we ran LARA's semantic-rule synthesis and refinement process to construct rules directly for the target runtime.

Comparing Transfer R0 with Transfer + Refine measures the effect of target-specific vulnerability feedback. Comparing Transfer + Refine with Target-Scratch examines whether the OpenClaw-derived rules provide useful prior knowledge beyond what can be learned from the target runtime alone.

We evaluated all three settings on the same 15 held-out vulnerabilities from Nanobot and Hermes. These cases were never used during rule construction or refinement, and all rule corpora were frozen before testing.

MethodDetected VulnerabilitiesHeld-out Recall
LARA-Transfer R010/1566.7%
LARA-Target-Scratch12/1580.0%
LARA-Transfer + Refine13/1586.7%

Comments on the paper

1 comment
AuthorsOpenReview ↗

Clarification of the Core Contribution, Empirical Evidence, and Claim Scope

Dear Reviewers and Chairs,

Thank you for the constructive reviews and discussion. We clarify the paper’s primary contribution and narrow two interpretations of the evaluation where appropriate.

LARA is not primarily a claim of state-of-the-art vulnerability detection. It asks: Can scarce, project-specific vulnerability/fix evidence be converted into reusable, executable security knowledge for auditing local-agent runtimes?

This matters because local-agent runtimes mediate between partially trusted user, model, tool, memory, and retrieved inputs and privileged effects such as shell execution, filesystem access, credential use, and network communication. Model- and prompt-level defenses cannot identify all implementation defects in authentication, authorization, path handling, isolation, tool dispatch, or network mediation. Runtime auditing is therefore a necessary complement to model- and behavior-level agent security.

To our knowledge, LARA is the first framework to formulate the construction and cross-runtime adaptation of a reusable security-rule corpus for local-agent runtimes as verifier-guided, rule-level semantic fuzzing:

  1. Rule-level search: The evolving objects are semantic security rules rather than grammar-generated inputs or isolated executable queries.
  2. Semantic mutation: Residual-conditioned Cull, Modify, and Augment actions revise applicability, entities, protected effects, required relations, scope, or grounding. These changes arise from applicability and validity reasoning rather than fixed syntactic operators.
  3. Verifier-guided feedback: Compilation, vulnerable/fixed execution, and no-regression checks decide which proposals enter the next corpus state. Residuals drive subsequent rounds until semantic saturation or a budget ceiling.
  4. Cross-runtime grounding: Security requirements are separated from runtime-specific bindings and CodeQL realizations, allowing requirements recovered from one runtime’s fixes to be re-grounded in independently implemented runtimes with limited security histories.
  5. Unlike IRIS, which infers taint specifications, and QLCoder, which synthesizes a query for each CVE, LARA evolves an intermediate corpus of reusable semantic requirements and re-grounds it across runtimes. This distinction—not merely using an LLM with CodeQL—is our paper’s core technical novelty.

The matched ablation strongly supports this primary contribution. Under the same residual feedback and deterministic validation, query-only refinement recovers 3 additional construction cases, whereas semantic mutation recovers 52. Thus, 49 of the 52 gains require changing rule semantics rather than merely refining CodeQL queries. This directly isolates the value of the semantic-rule layer. We interpret it as construction-set evidence for the synthesis mechanism, not held-out generalization.

We also clarify the remaining results:

  • The 117-case held-out OpenClaw evaluation demonstrates localization of unseen vulnerability-related code, not vulnerable/fixed discrimination under the Success criterion. We withdraw the stronger interpretation.
  • The transferred R0 result of 10/15 shows that source-derived rules provide useful detections before target vulnerability/fix feedback, supporting transfer as a viable feedback-free initialization.
  • The final 13/15 versus 12/15 comparison does not establish that transfer achieves better final performance after both methods use all target evidence. Accordingly, we do not interpret these results as establishing target-data efficiency or superiority over target-from-scratch synthesis.
  • Frozen-corpus auditing surfaced 25 previously unreported, PoC-supported candidates across four runtimes, including candidates in an independently implemented runtime using an unchanged transferred corpus. This demonstrates actionable audit utility, but does not estimate analyzer precision or vulnerability prevalence.

Accordingly, the transfer results support useful feedback-free initialization and localization, while target evidence remains important for vulnerable/fixed discrimination.

We ask that the paper be evaluated under these bounded contributions: LARA introduces a novel verifier-guided method for evolving reusable semantic security requirements; the matched ablation demonstrates that semantic mutation drives the construction gains; historical fixes provide useful initialization and localization for low-evidence runtimes; and frozen corpora provide actionable locations for human auditing.

These qualifications narrow two interpretations of the evaluation but do not alter the central contribution or its supporting evidence. LARA bridges agent security and software security by treating the privileged agent runtime as a security-critical layer and transforming scarce historical fixes into reusable, executable audit knowledge.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.