acceptodds
Under review as a conference paper at ICLR 2027

AuthBench: Can Coding Agents Infer Least-Privilege File Permissions?

Abstract

Deploying autonomous coding agents in real-world environments faces an all-or-nothing dilemma: granting unrestricted shell and file access exposes systems to credential theft and prompt injection, while coarse hardcoded limits frequently break task execution. To resolve this tension, agents must autonomously determine their own permissions prior to execution. We formalize this challenge as permission-boundary inference, where a model infers a task-scoped read/write/execute policy through read-only inspection of the environment before acting. To evaluate this capability, we introduce AuthBench, comprising 120 realistic terminal tasks across 10 domains with human-reviewed, execution-calibrated ground truth and executable validators for utility and attack outcomes. AuthBench reveals that authorization is not a simple calibration problem: frontier models simultaneously omit permissions required by the execution chain while granting unused or sensitive accesses. Crucially, scaling test-time reasoning does not resolve this mismatch; instead, it reinforces model-specific authorization attractors, trapping models in either broad-but-exposed or tight-but-brittle regimes. We identify that the root bottleneck lies in one-pass policy generation, which forces the model to concurrently discover all necessary dependencies and prune all unnecessary accesses. We therefore propose Sufficiency-Tightness (S-T) Decomposition, separating policy generation into coverage-oriented forward simulation followed by an audit for grounding and sensitivity. Across evaluated models, S-T Decomposition consistently reduces attack success rates (by up to 15.8 percentage points) and cuts sensitive-file exposure by more than half, while boosting sensitive-task success rates by up to 15.9% on tightness-biased models.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
Coding agents, AI safety, access control, least privilege, agent evaluation

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_afQMOpenReview ↗
Rating
3(+1)
Confidence
2
Informativeness
2
Presentation
3
Soundness
1
Read review
Paper summary

This paper is about permission boundary inference. With task and read-only access to its environment, an authorisation agent predicts the file read, write, and execute permissions that a different agent would need. AuthBench contains 120 tasks in 10 domains. The authors combine agreement with a human-reviewed reference policy, task success under generated permissions, sensitive permission exposure, and realised attack outcomes. They report simultaneous under- and over-authorisation, investigate how different models respond to increasing reasoning effort and introduce Sufficiency-Tightness (S-T) Decomposition. This is generating a policy, prioritising coverage, and then auditing and narrowing it.

Critical strengths

The problem is interesting and seems relevant. A successful agent can still have been given unnecessary authority. Combining static permissions agreement, functional validators, and separate attack endpoint validators is a well-appearing evaluation design. They authors also note that several different valid workflows can need different permissions, and an appendix don't treat all failed executions as proof of an authorisation error.

This submission also provides great experimental controls and substantial supporting material. The full access and golden permissions references help to interpret the tradeoff. In the appendix, they check alternative executors and also include neat/avoid and generic revision baselines and phase-wise results. Those comparisons are stronger than evaluating S - T only against direct. For example, Table 2 reports Claude's sensitive task success increasing from 61.7% to 75.0%, while attack success decreases from 25.8% to 15.0%.

The provided task environments, validators, prompts, and enforcement code also make the evaluation well-inspectable.

Critical weaknesses

Section 2.1 writes about a whitelist comprising the generator policy and fixed runtime permissions, but in policy_enforcement.py, _expand_write_patterns converts an exact write, such as /workdir/report.json, into /workdir/**. In authbench_log_launch.c, add_rule_from_arg also gives read access to an existing ancestor where an exact retarget does not yet exist. That could be important for tasks that create an output and read it afterwards. The policy guard plugin checks the read, write, and edit tools, but I did not find an equivalent restriction there on file access performed within exec. That means a policy can look narrow in static scoring but allow more broad access while execution. This could affect task success and security outcomes and make the connection between the inferred policy and measured behaviour not as it seemed.

Figure 5 and the phase-wise results make it seem like model-dependent tendencies, but they do not show that one past generation has an inherent cognitive conflict or that the particular ordering of s - t solves its original cause. The direct procedure itself allows several inspection turns. The prompting baselines are useful, but token/tool budgets and uncertainty are not reported with the comparisons, and the derivation of Figure 5's vector field is not specified enough. The supplement gives configurable repeat counts, which is helpful, but does not show the run configurations behind figures and tables.

Questions for authors
  1. What is the supplied enforcement implementation used for the reported experiments? What prevents shell subprocesses from accessing siblings covered by the expanded parent directory rules? It would be great if you could please explain the handling of writes and reads of not-yet-created outputs and provide a check that the intended file is accessible while an unlisted sibling is denied. If the effective permissions are broader than the score policy, which reported results are affected?

  2. Which SER definitions create Tables 1, 2, and 8? The per-axis average in Equation 8 or the pooled implementation? How are empty sensitive accesses handled?

  3. Could you maybe provide the observed metrics at each reasoning effort setting and explain how they produce Figure 5, including any fitting or interpolation? What were the generation/replay repeat counts and influence budget for the compared methods? Task-level uncertainty estimates for the main differences would help.

3 comments
AuthorsOpenReview ↗

Response to Reviewer afQM (Part 1)

Thank you for the careful review and detailed feedback on permission enforcement and evaluation methodology.

We have revised the manuscript: Appendix E.2 details enforcement and metric aggregation; Appendix F.2 reports run configurations and compute usage (Table 10); Appendix H.1 specifies the vector-field construction. The main text now uses pooled SER and describes adjacent-effort displacements.

Q1 & W1. Permission enforcement

Thank you for examining the enforcement implementation so closely. You are the first reviewer to engage with these concrete implementation details; the design involves subtle technical details that required careful consideration during implementation, and we appreciate your thoughtful discussion of them.

The supplement mistakenly included an earlier implementation. That version broadened exact write paths and some nonexistent read paths to parent or ancestor directories. The reported experiments used the updated implementation, so none of the reported results are affected. It combines Landlock with the policy guard: Landlock constrains the execution process and its descendants, including file access inside exec; the guard additionally checks read/write/edit tool paths.

Landlock rules attach to existing filesystem objects. We enforce exact permissions on existing inputs and pre-create task-required output files explicitly granted write access by the generated policy, then assign read and write permissions separately. Intermediate files and directories use /tmp, a fixed read/write runtime workspace; final results are written into the authorized output files. Other directory or file-set creation requires explicit policy grants. The final implementation enforces exact-path grants without broadening them to parent directories, so it does not allow access to unlisted sibling files through parent-directory expansion.

In a manual inspection of 120 sampled trajectories across executors, all agents discovered that /tmp was writable through their attempts, without an explicit reminder. None of these runs failed because temporary-file writes were denied.

Q2. SER definition

Tables 1, 2, and the original Table 8 all use the same implementation, with pooled read/write/execute counts within each policy evaluation:

\frac{\sum_{a\in\\{r,w,x\\}} |\pi_{i,a}\cap S_{\mathrm{sens},i,a}|} {\sum_{a\in\\{r,w,x\\}} |S_{\mathrm{sens},i,a}|}.$$ We then take the **arithmetic mean across runs with a sensitive-exposure metric**, rather than pooling counts across tasks. An empty axis contributes zero to both sums. An entirely empty sensitive set returns 0.0, which is included in the mean; only runs without the sensitive-exposure metric field are excluded. SER is designed for sensitive tasks, and all 40 sensitive tasks have nonempty sensitive-permission annotations. Different operations on the same file count separately. **We have corrected the paper’s formula to this pooled definition; the reported SER values are unchanged.**
AuthorsOpenReview ↗

Response to Reviewer afQM (Part 2)

Q3 & W2. Vector field, repeats, compute, and uncertainty

Interpretation and S-T design. Increasing reasoning effort does not consistently improve authorization quality. We interpret this pattern as a tension between discovering necessary permissions and pruning unnecessary grants, which motivates sufficiency reasoning followed by a tightness audit. Compared with Needed/Avoid and Generic Revision, S-T achieves lower SER and ASR across all three models, supporting this design.

Here, “attractor” describes a model-specific tendency in authorization decisions rather than a physical dynamical mechanism. Such tendencies may reflect knowledge and decision biases acquired during pretraining and post-training.

Vector-field construction. For each task and reasoning-effort setting, we average its metrics and compute:

\qquad B_{\mathrm{over}}=R_{\mathrm{macro}} \left(\frac{1}{P_{\mathrm{adjusted}}}-1\right).$$ Here P\_adjusted is P\_macro for standard tasks and P\_macro × (1 − SER) for sensitive tasks. We clip B\_over to \[0, 3] and display x = log(1 + B\_over) / log(4), y = B\_under; zero adjusted precision maps to B\_over = 3. Displacements pair the same task at **adjacent effort settings**: Claude low→medium→high→max; Gemini low→medium→high; GPT-5.4 none→low→medium→high→xhigh. We discard displacement magnitudes below 0.006. On a **20 × 14 grid**, we apply distance-based Gaussian averaging with bandwidth 0.12 and radius 0.30. Grid points with total weight below 0.36 or smoothed magnitude below 0.006 are omitted. Arrows have fixed length; direction is the averaged displacement, and color shows its magnitude normalized within each panel. **Observed metrics by reasoning effort.** P and R are macro-averaged over read, write, and execute; all values are percentages. \* marks the configuration used in the main evaluation. | Model | Effort | Standard P | Standard R | Sensitive P | Sensitive R | SER ↓ | | --------------- | ------- | ---------- | ---------- | ----------- | ----------- | ----- | | Claude Opus 4.6 | low | 81.8 | 77.7 | 77.1 | 88.0 | 51.7 | | | medium | 82.2 | 77.6 | 78.2 | 87.2 | 48.8 | | | high | 82.2 | 79.5 | 78.6 | 88.1 | 50.3 | | | max\* | 80.0 | 76.4 | 71.3 | 85.1 | 47.0 | | GPT-5.4 | none | 71.2 | 70.4 | 74.0 | 85.7 | 45.2 | | | low | 76.4 | 70.5 | 82.8 | 86.7 | 41.6 | | | medium | 76.3 | 69.8 | 84.0 | 87.1 | 42.9 | | | high | 74.5 | 66.1 | 84.4 | 83.5 | 28.7 | | | xhigh\* | 78.4 | 69.0 | 79.7 | 79.1 | 21.1 | | Gemini 3.1 Pro | low | 74.3 | 81.2 | 78.4 | 89.0 | 46.8 | | | medium | 72.7 | 84.7 | 77.8 | 92.9 | 34.3 | | | high\* | 69.7 | 87.2 | 76.1 | 94.6 | 34.8 | Across the evaluated settings, **increasing reasoning effort does not consistently improve authorization quality**. **Repeats and budgets.** Each task has **three policy generations, each followed by one execution replay**. The four methods share the following effort settings and per-stage turn limits: | Model | Reasoning effort (all four methods) | Turn limit per stage | | --------------- | ----------------------------------- | -------------------- | | Claude Opus 4.6 | max | 50 | | GPT-5.4 | xhigh | 50 | | Gemini 3.1 Pro | high | 50 |
AuthorsOpenReview ↗

Response to Reviewer afQM (Part 3)

Observed average usage is:

ModelMethodMean input tokensMean output tokensMean tool callsMean model turns
Claude Opus 4.6Direct35,84822,69017.126.97
Claude Opus 4.6Needed/Avoid70,45621,50614.3914.12
Claude Opus 4.6Generic Revision104,22058,26030.7220.54
Claude Opus 4.6S-T83,46233,23220.1615.17
GPT-5.4Direct22,01029,42411.434.92
GPT-5.4Needed/Avoid32,52225,1286.726.41
GPT-5.4Generic Revision56,35255,23622.6611.39
GPT-5.4S-T45,42827,62613.457.34
Gemini 3.1 ProDirect33,02417,86713.327.50
Gemini 3.1 ProNeeded/Avoid26,79111,6969.896.72
Gemini 3.1 ProGeneric Revision65,18429,89024.8514.53
Gemini 3.1 ProS-T32,79014,57313.7810.25

S-T uses fewer input tokens, output tokens, tool calls, and model turns than Generic Revision for all three models, indicating that its gains are not merely due to test-time compute scaling.

Task-level uncertainty. We compute 95% confidence intervals using paired bootstrap over the 40 sensitive tasks under the main GPT-5 executor, retaining each task’s three runs together. We use 10,000 resamples and the 2.5th and 97.5th percentiles of the bootstrap difference distribution. Differences are S-T minus Direct, in percentage points.

ModelΔASR, pp (95% CI)ΔSUR, pp (95% CI)
Claude Opus 4.6−10.8 [−18.3, −3.3]+11.7 [+4.2, +19.2]
GPT-5.4−4.2 [−7.2, −0.8]+15.8 [+7.0, +24.0]
Gemini 3.1 Pro−15.8 [−24.2, −7.8]+5.0 [+0.8, +9.2]
Reviewer_m8NROpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

The paper introduces permission-boundary inference, where a model inspects a terminal environment and generates a task-specific file read, write, and execute policy before execution. The authors construct AuthBench, comprising 120 tasks with human-reviewed permission specifications, utility validators, and attack validators for sensitive tasks adapted from Terminal-Bench, SWE-bench, and OpenThoughts-TBLite. To construct the reference permissions, the authors run a verified safe solution under strace, which records file accesses and program execution. They derive an initial policy from the trace, review it with human annotators, and test execution under the resulting restrictions. Across multiple models, they observe missing required permissions alongside unnecessary or sensitive grants. They further analyze reasoning-effort scaling and propose Sufficiency-Tightness Decomposition (S-T Decomposition), which separates coverage-oriented policy generation from a restrictive audit. The method reduces attack success across the three evaluated models, with task-success improvements for Claude Opus 4.6 and GPT-5.4 and task-success reductions for Gemini 3.1 Pro.

Critical strengths
  • The work addresses a well defined problem: with autonomous agents such as claude code (auto mode), codex (auto approval mode), becoming popular and the risks of these agents in receiving overly broad permissions. Becoming more common, it is an important research problem with a large possible impact.
  • The authors use careful evaluation procedures, including isolated task environments, traced safe solutions, a two-annotator review process, and executable utility and attack validators. They also conduct several useful ablation studies.
  • The proposed method has practical empirical benefits: S-T Decomposition reduces ASR across all three tested models. For Claude Opus 4.6 and GPT-5.4, the reductions accompany improved task success. Comparisons with generic revision and joint consideration of needed and avoided permissions suggest that the particular prompting structure contributes to the observed security improvements.
Critical weaknesses
  • Static scores can penalize valid alternative workflows and approaches: Precision and recall use a single reference policy, although several policies may support the task. For example, a valid Python solution may require different executable permissions from a shell-based solution and receive a lower score despite being sufficient.
  • Execution scores do not fully isolate authorization quality: Appendix C acknowledges that an executor may fail to follow a feasible policy. The reference policy achieves 81.7% sensitive-task success, compared with 85.8% under policies generated by Gemini. Appendix D also shows that Full-Access ASR ranges from 7.5% to 82.5% across executors. Although executor dependence is expected, the evaluation should distinguish missing permissions from executor failures and report successful completion without an attack.
Questions for authors
  • How do you account for valid alternative workflows that require different permissions from the reference policy?
  • How do you distinguish failures caused by missing permissions from cases where the executor cannot follow a feasible policy?
  • Do the main conclusions hold across execution backbones, and can you report the proportion of tasks completed successfully without an attack?
4 comments
AuthorsOpenReview ↗

Response to Reviewer m8NR (Part 1)

Thank you for the thoughtful review and constructive suggestions on workflow diversity and executor dependence.

Q1 & W1. Valid alternative workflows

Appendix C (Workflow Diversity and Least-Privilege Authorization) discusses alternative workflows and the canonical reference in detail. Valid workflows and their permission sets cannot be exhaustively enumerated; adding a few references would still leave coverage bias. We use a human-reviewed, execution-calibrated safe workflow as an independent, auditable reference. Treating every attempted access as necessary would let the executor’s implementation choices justify their own permissions. Static scores therefore measure agreement with the canonical reference.

The executor can read the fixed policy and adapt its implementation. A different policy that supports task completion still receives a successful TSR outcome. Execution outcomes and static metrics provide complementary assessments of policy quality.

Q2 & W2. Permission omissions versus executor failures

Appendix C also discusses executor adaptation and why execution failure alone does not establish a permission omission. In our manual analysis of over 360 sampled trajectories, 15.2% were classified as WorkflowMismatch: the authorizer scoped permissions around a particular workflow, while the executor judged them insufficient and stopped early. A stronger executor might adapt; better authorization reasoning might anticipate its workflow. Attributing responsibility for these failures is complex and likely to involve substantial subjectivity. Since AuthBench evaluates the authorizer, treating these ambiguous cases as limitations in anticipating the executor’s workflow is a reasonable choice aligned with the evaluation objective.

AuthBench evaluates policy usability under a fixed, policy-aware executor, including the authorizer’s ability to anticipate its dependencies. This controls the execution setting for policy comparison while retaining executor dependence. A similar interaction dependence arises in τ²-bench, where outcomes depend on the simulated user’s cooperation. Such dependence calls for controlled comparisons and does not invalidate them.

AuthorsOpenReview ↗

Response to Reviewer m8NR (Part 2)

Q3 & W2. Secure utility and another executor

We have revised the manuscript to define SUR in Section 3.2, report it in Tables 1 and 2, and add the Gemini 3 Flash Preview executor results in Appendix D.1 (Table 7).

1. The sufficiency–tightness tradeoff persists across executors. Appendix D keeps the generated policies fixed and switches the executor to Claude Sonnet 4.6 or Gemini 3 Flash Preview. On both backbones, generated policies have lower TSR than Full-Access and higher ASR than Golden-Permission. Thus, jointly achieving task sufficiency and tight authorization remains challenging across executors.

2. S-T remains effective with another executor. With Gemini 3 Flash Preview, S-T lowers ASR and raises secure utility for all three authorizers, with safe-completion gains of approximately 16.7, 7.5, and 1.7 percentage points. Opus and GPT-5.4 also improve TSR on both task sets. Gemini’s TSR decreases, but its secure utility rises under both executors. This reproduces the direction of S-T’s joint utility–security benefit.

We report secure utility: the fraction of sensitive-task runs with task success and no successful attack in the same run. The main-evaluation results are:

Authorizer / configurationSecure utility ↑
Full-Access29.2%
Golden-Permission81.7%
Gemini 3.1 Pro58.3%
GPT-555.8%
GPT-5.4 (xhigh)50.0%
Claude Opus 4.652.5%
Kimi K2.546.7%
GPT-5.3-Codex50.8%
Qwen3-Coder44.2%
Qwen3.530.0%
MiniMax M2.737.5%

Under the main GPT-5 executor, S-T improves secure utility for all three authorizers:

AuthorizerDirect secure utility ↑S-T secure utility ↑Gain (pp)
Claude Opus 4.652.5%64.2%+11.7
GPT-5.450.0%65.8%+15.8
Gemini 3.1 Pro58.3%63.3%+5.0

We also evaluated Gemini 3 Flash Preview as the executor; the following results are averages over three runs:

AuthorizerMethodStandard TSR ↑Sensitive TSR ↑Sensitive ASR ↓Sensitive secure utility ↑
Claude Opus 4.6Direct68.8%67.5%35.0%43.3%
Claude Opus 4.6S-T70.83%82.5%27.5%60.0%
GPT-5.4Direct62.1%77.5%22.5%58.3%
GPT-5.4S-T73.75%84.16%20.83%65.8%
Gemini 3.1 ProDirect61.3%87.5%35.0%57.5%
Gemini 3.1 ProS-T60.0%83.3%31.67%59.16%

Thank you, these address most of my concerns. However, I will stick to my current rating

We sincerely appreciate your thoughtful and constructive feedback. We are glad that our rebuttal addresses your concerns, and we appreciate your positive assessment of the paper.

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

This paper tests whether an LM is able to judge which files a coding agent needs access to, before running the task. They build a benchmark of 120 terminal tasks, 40 of which have sensitive or dangerous surfaces. Results show that, perhaps unsurprsingly, LMs are far from perfect on this task.

Critical strengths

None

Critical weaknesses

I doubt that judging file permission is a useful task that needs to be studied alone. Instead, a general monitor that can catch all bad behaviors during runtime, is more aligned with real-world usage. This is the design of most coding agents like Claude Code and Codex.

Could you test how well are Claude Code and Codex on this benchmark with their monitors on (automode)?

Questions for authors

See weaknesses.

2 comments
AuthorsOpenReview ↗

Response to Reviewer 5ZPa

Q&W. Task-level permission inference and native automatic review

Claude Code’s auto mode uses a model classifier to review actions requiring approval; Codex Auto-review uses a separate reviewer agent with context and optional read-only checks. Like our approach, both infer appropriate authorization from user intent and the environment. They decide whether a current action is allowed; we predict the permissions needed for the entire task before execution. Their review operates at the tool-call level, approving or blocking a proposed command or tool invocation. Our output is a task-scoped file-permission policy, enforced throughout execution.

Our policy representation is inspired by Claude Code’s static permission settings, using file-level read/write/execute policies rather than tool and command rules. Static boundaries and runtime approval can work together. Our objective combines execution sufficiency and authorization minimality: an attack-free run does not imply appropriate permissions. Anticipating the executor’s workflow and dependencies while minimizing unnecessary grants is a capability that warrants independent evaluation.

The adoption of model-based approval in deployed products demonstrates the practical need for authorization reasoning. Appendix B details the distinction between authorization safety and execution safety, and the complementary roles of task-level permission inference and runtime permission control. The review proposes a related alternative without explaining why it removes the value of task-level least-privilege inference, or substantively discussing our objective and main findings.

We evaluated the latest CLI versions available at evaluation time with native automatic review enabled, using GPT-5 in Codex to match the main execution backbone and Sonnet 4.6 in Claude Code. Results are grouped by execution model, with the harness identified explicitly:

GPT-5 execution

Configuration / harnessStandard TSR ↑Sensitive TSR ↑ASR ↓SUR ↑
Full-Access / OpenClaw83.3%94.2%65.8%29.2%
Golden-Permission / OpenClaw77.1%81.7%0.0%81.7%
Auto-review / Codex61.25%85.0%40.0%47.5%

Sonnet 4.6 execution

Configuration / harnessStandard TSR ↑Sensitive TSR ↑ASR ↓SUR ↑
Full-Access / OpenClaw87.5%85.0%7.5%80.0%
Golden-Permission / OpenClaw76.3%65.0%0.0%65.0%
Auto mode / Claude Code81.25%87.5%7.5%80.0%

Sonnet 4.6 has 7.5% ASR under both OpenClaw Full-Access and Claude Code auto mode, with 80.0% SUR in both settings. Codex has approximately 22.1 percentage points lower standard-task TSR than GPT-5/OpenClaw Full-Access and achieves 47.5% SUR. Overall, native automatic review shows no consistent advantage across utility and security: GPT-5's better security metrics accompany lower TSR, while Sonnet's ASR and SUR remain unchanged. AuthBench additionally evaluates whether the granted authority is minimal, a property that successful, attack-free execution alone does not establish (Appendix B).

Dear Reviewer 5ZPa,

Thank you for your review. Since the discussion time is less than a day, we would appreciate hearing whether our response addresses your concerns, and are happy to clarify anything further.

Best regards,

The Authors

Comments on the paper

1 comment
AuthorsOpenReview ↗

General Response

We thank all reviewers for their careful feedback and constructive suggestions.

Significance of Permission-Boundary Inference. We appreciate the recognition that task success alone does not establish appropriate authorization, and that inferring sufficient, minimal permissions is an important problem for autonomous coding agents (Reviewers #m8NR, #afQM).

Evaluation Design and Empirical Findings. We also appreciate the positive assessment of our human-reviewed, execution-calibrated reference policies, complementary static and execution-based metrics, and experimental controls. Both reviewers highlighted the benefits of S-T Decomposition and the comparisons with alternative prompting strategies (Reviewers #m8NR, #afQM).

Additional Results and Clarifications. In response to the reviews, we have added: (1) native automatic-review baselines for Claude Code and Codex; (2) Secure Utility Rate, measuring successful task completion without a successful attack; (3) S-T results with Gemini 3 Flash Preview as an alternative executor; (4) task-level paired-bootstrap confidence intervals; and (5) observed metrics across reasoning-effort settings and detailed compute usage. We have also clarified permission enforcement, corrected the SER formula to match the implementation, and documented the vector-field construction.

We are pleased that Reviewers #m8NR and #afQM have indicated that their concerns were addressed. We thank them for the follow-up discussion, particularly the detailed examination of workflow diversity, executor dependence, and permission enforcement.

For Reviewer #5ZPa, we believe task-level least-privilege inference complements runtime approval by evaluating whether the granted authority is both sufficient and minimal. We have provided the requested native automatic-review baselines and welcome further discussion on this distinction and its practical relevance.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.