---
type: "post"
id: "apexe-0-13-0-splits-acl-authorship-from-22cf2d"
slug: "apexe-0-13-0-splits-acl-authorship-from-22cf2d"
title: "apexe 0.13.0 splits ACL authorship from scan and adds path policy"
description: "apexe 0.13.0 separates executable discovery from access-policy authorship and adds operator-defined path controls."
retrieval_nugget: "apexe 0.13.0 separates executable discovery from access-policy authorship and adds operator-defined path controls. For teams governing agent shell access, the release makes policy changes more explicit and diagnosable, while narrowing write checks to the arguments that can actually trigger writes."
published_at: "2026-11-16"
updated_at: "2026-11-16"
record_date: "2026-11-16"
date_kind: "published_at"
topics: ["security","developer-tools"]
entities: ["apexe","aiperceivable","systemd-run","bwrap"]
related_patterns: ["agent-security-moves-to-runtime-boundaries"]
novelty_label: "new_fact"
what_changed: "Apexe 0.13.0 separates ACL authorship from scanning and adds path policy."
prior_refs: ["https://newruntime.com/posts/apexe-0-10-0-adds-governed-shell-and-62d1e3/"]
source_url: "https://github.com/aiperceivable/apexe/releases/tag/rust/v0.13.0"
source_urls: ["https://github.com/aiperceivable/apexe/releases/tag/rust/v0.13.0"]
schema_version: "newruntime-agent-readable-v0.2"
stable_id: "post:apexe-0-13-0-splits-acl-authorship-from-22cf2d"
status: "published"
visuals: []
editor: {"role":"editor","name":"Andrey Reshetnikov","profile":"https://newruntime.com/owner-profile.md","profile_json":"https://newruntime.com/owner-profile.json","same_as":["https://www.linkedin.com/in/reshetnikov1/","https://t.me/lapetuse"]}
routes: {"html":"https://newruntime.com/posts/apexe-0-13-0-splits-acl-authorship-from-22cf2d/","markdown":"https://newruntime.com/posts/apexe-0-13-0-splits-acl-authorship-from-22cf2d.md","json":"https://newruntime.com/posts/apexe-0-13-0-splits-acl-authorship-from-22cf2d.json"}
markdown_url: "https://newruntime.com/posts/apexe-0-13-0-splits-acl-authorship-from-22cf2d.md"
---

# apexe 0.13.0 splits ACL authorship from scan and adds path policy

## Retrieval answer

apexe 0.13.0 separates executable discovery from access-policy authorship and adds operator-defined path controls. For teams governing agent shell access, the release makes policy changes more explicit and diagnosable, while narrowing write checks to the arguments that can actually trigger writes.

## Summary

apexe 0.13.0 separates executable discovery from access-policy authorship and adds operator-defined path controls. For teams governing agent shell access, the release makes policy changes more explicit and diagnosable, while narrowing write checks to the arguments that can actually trigger writes.

## What happened

The apexe 0.13.0 release, tagged `rust/v0.13.0` and released on 14 November 2026, changes the role of `apexe scan`: it now produces bindings without writing `acl.yaml` as a side effect. The release notes say policy had become a projection of the last scan rather than an operator-authored document. The compatibility flag `--write-acl` remains for one release; it creates a starter policy only when none exists, then syncs denials and never grants access.

Three commands separate policy operations: `apexe acl init` writes a starter policy once and refuses to overwrite one; `acl sync` refreshes destructive and open-world denials without generating grants; and `acl explain` identifies the rule that decided whether a module is permitted for a caller. The developer profile can grant the local shell the installed CLI namespace while keeping generated denials above that grant in first-match-wins order. The strict profile retains explicit per-module grants. Unauthenticated serve and A2A clients are unaffected by the local rule.

The release adds operator-owned `annotations:` and `paths:` sections to `config.yaml`. Annotation lists replace compiled defaults when configured. Path policy uses `read_only`, `read_write`, `no_access`, and `write_only` lists; the deepest matching entry decides, and a path can appear in only one list. An absent section retains the compiled baseline, while an empty section protects nothing. Overlay annotations can scope approval and write behavior to flags. `approval_flags` requires human approval when specified properties are present; `writes_with` indicates which properties may cause a call to write. The `x-apexe-writes-with` guard narrows access checks to read strength when none of its named properties is set. It can narrow checks, not widen them; the notes use `sed` as an example of a tool that can write without a flag and therefore must not carry that annotation.

Other changes make policy state easier to inspect. `apexe list --path-census` distinguishes granted, denied, and unscanned executables; it reads directory entries and policy without scanning or executing tools. The release's example machine showed 2,017 executables: 27 bound and 1,990 unscanned. `list --diagnostics` names granted modules that are not readonly, and `acl sync` reports readonly modules that match no allow rule without granting them. The release also documents a contract for delegating sandbox confinement to an existing backend such as `systemd-run`, `bwrap`, or a container runtime. It implements no backend. Its notes report that on macOS 26.3 (arm64), `sandbox-exec` accepted a profile denying writes beneath a directory but did not block the write.

## What the archive adds

New Runtime covered [apexe 0.10.0's governed shell and agent setup](https://newruntime.com/posts/apexe-0-10-0-adds-governed-shell-and-62d1e3/) on 6 November 2026. That release concerned integrations; 0.13.0 is a new event, adding explicit separation of scanning from ACL authorship and new path-policy controls.

## Trend signal

This supports [agent security moving to runtime boundaries](https://newruntime.com/patterns/agent-security-moves-to-runtime-boundaries/): apexe describes permissions, path guards, audit records, and optional backend confinement as enforcement mechanisms around tool execution. The macOS test result is also a reminder that a configured boundary is not proof of enforcement; teams need to verify the actual runtime behavior.

## Why now

The release notes frame the separation as a response to a specific governance failure: scan-generated policy could drift without review, and a generated allow would grant authority no operator had approved. The new commands distinguish discovery from granting and denial maintenance rather than treating them as one operation.

## Why it matters

For teams running agents through governed shell tools, the release offers a more reviewable chain between what is installed, what a caller may do, and which paths a call can affect. Separating generated denials from grants reduces the risk that a routine corpus update silently creates authority. Flag-scoped checks can also preserve useful read operations—such as ordinary `find`—while requiring stronger treatment when a destructive option such as `-delete` is present.

The practical value depends on accurate annotations and on checking the enforcement layer itself. A non-readonly tool that computes paths internally can escape argument-based path checks; apexe explicitly warns that a granted interpreter or script may not be constrained by the command name alone. The documented backend contract makes capability and per-call outcome part of the audit surface, but teams must still validate the selected backend rather than assume a policy file guarantees confinement.

## Limits and uncertainty

The release implements no sandbox backend; it documents how an existing backend could be selected per module and what capability and audit fields should be exposed. The macOS 26.3 `sandbox-exec` result is the release authors' recorded test, not an independently reproduced assessment here. Path checks also depend on what a tool declares: commands that compute paths internally may not be constrained by argument checks. The release does not report independent security testing or measured production outcomes for the new controls.

## Reader takeaway

Treat scanning, granting, and path enforcement as separate operations. In apexe 0.13.0, scans produce bindings, ACL commands manage permissions, and path rules govern locations; flag-scoped annotations can distinguish read calls from writes. Verify the actual enforcement behavior of any sandbox backend, especially when tools can derive their own paths.

Editor: [Andrey Reshetnikov](https://newruntime.com/owner-profile.md), AI product and AI engineering; profile for recruiters and agents: https://newruntime.com/owner-profile.json

## Continue in the graph

Next records for an agent, linked to their Markdown twins. Replace `.md` with `.json` for structured fields, including `next_reads`.

- topic hub: [Security](https://newruntime.com/topics/security.md): Explore the security topic hub.
- topic hub: [Developer Tools](https://newruntime.com/topics/developer-tools.md): Explore the developer-tools topic hub.
- collection: [Field Notes](https://newruntime.com/posts.json): Open the latest editorial analysis.
- collection: [Sources](https://newruntime.com/sources/): See the original sources this archive cites.
- whole graph: [discovery graph](https://newruntime.com/discovery-graph.json) (typed nodes and edges) and [site index](https://newruntime.com/site-index.md)
