---
title: "Deny by Default (Default Deny) for AI Agents, Explained"
description: "Deny by default means an AI agent starts with no access and gets only what you grant. Why denylists and auto-approve fail, and how to set it up per OS."
canonical: "https://cosmonic.com/ai-sandbox/principles/deny-by-default/"
---

[Learning Hub](https://cosmonic.com/ai-sandbox/) **·** [Principles](https://cosmonic.com/ai-sandbox/principles/) **·** **Deny by default**

# Deny by default: why AI agents should start with nothing

How to ensure that AI agents get only the access you grant.

Last updated October 2026

1. [Principle 1 Isolation](https://cosmonic.com/ai-sandbox/principles/isolation/)
2. [Principle 2 Deny by default](https://cosmonic.com/ai-sandbox/principles/deny-by-default/)
3. [Principle 3 Least authority](https://cosmonic.com/ai-sandbox/least-privilege-ai-agents/)
4. [Principle 4 Policy enforcement points](https://cosmonic.com/ai-sandbox/principles/policy-enforcement-points/)
5. [Principle 5 Controlled information flow](https://cosmonic.com/ai-sandbox/principles/lethal-trifecta/)
6. [Principle 6 Composition](https://cosmonic.com/ai-sandbox/principles/composition/)

[Download the principles matrix (PDF)](https://cosmonic.com/ai-sandbox/principles/sandboxing-principles-matrix.pdf)

Without deny by default, an agent told to fix a failing test can also read `~/.aws/credentials`, because nothing said it couldn't. Deny by default flips that: the agent starts with no access, and you add only what the task needs.

Deny by default is one of [The 6 Principles of Secure Agent Platforms](https://cosmonic.com/ai-sandbox/principles/). In the [series' building analogy](https://cosmonic.com/ai-sandbox/principles/#the-building-and-the-guard-the-six-principles-as-one-story), the room is built with no doors at all, so an agent with zero capabilities can't touch anything, even by accident. We will only specifically grant (allow list, not a deny list) the capabilities our agent must have to perform its function:

![Deny by default compared with default allow for AI agents: a closed door that opens only for granted access](https://cosmonic.com/ai-sandbox/principles/deny-by-default/deny-by-default-hero-day.webp)

> The most important takeaway
>
> Deny by default is a security rule that says a program starts with no access at all. It can reach only the files, commands, hosts and secrets you grant on purpose. For AI agents, it also means no auto-approve, no auto-started tools, and no denylist pretending to be a fence.

## What does deny by default mean?

Deny by default means every request is refused unless a rule explicitly allows it. NIST defines it for firewalls: "block all inbound and outbound traffic that has not been expressly permitted by firewall policy"[^1].

An agent touches more than network traffic, so apply the same rule to all resources it can reach, here we will discuss the 6 big categories: files, network, commands, secrets, config and hooks, and the host's control plane (the [policy enforcement points](https://cosmonic.com/ai-sandbox/principles/policy-enforcement-points/) page covers each).

In 1975, Saltzer and Schroeder called it fail-safe defaults: "Base access decisions on permission rather than exclusion"[^2][^3]. If you forget an allow rule, something breaks and someone notices. If you forget a deny rule, the attack works and nobody notices.

> What are fail-safe defaults?
>
> Fail-safe defaults is the design rule that a system refuses access unless it was granted, so a missing rule fails closed. A hotel key card works this way: if the front desk forgets to program it, you are locked out, not let into every room.

![Why default deny fails safe: a forgotten allow rule breaks a feature, a forgotten deny rule lets an attack through](https://cosmonic.com/ai-sandbox/principles/deny-by-default/allowlist-vs-denylist-forgotten-rule-day.webp)

### Default deny, implicit deny and fail-safe defaults: one idea, three names

Implicit deny is the invisible last rule in a firewall or access list that drops anything no earlier rule allowed. It blocks all traffic that matches no allow rule. In nftables, you get it by giving a base chain policy drop[^4].

> What is implicit deny?
>
> Implicit deny is the unwritten rule at the bottom of every access list: if nothing above said yes, the answer is no. It works like the list at the building's front desk: anyone not on it stays outside.

### Where deny by default fits

[Isolation](https://cosmonic.com/ai-sandbox/principles/isolation/) draws the wall. Deny by default builds the room with no doors, [least authority](https://cosmonic.com/ai-sandbox/least-privilege-ai-agents/) cuts only the doors the job needs, and [policy enforcement points](https://cosmonic.com/ai-sandbox/principles/policy-enforcement-points/) guard each door.

## Deny by default vs default allow

Default allow starts open and blocks known bad things. Deny by default starts closed and opens known good things.

|  | Default allow | Deny by default |
| --- | --- | --- |
| Starting point | Everything is reachable | Nothing is reachable |
| A forgotten rule | Lets something through | Breaks a feature |
| What an attacker needs | One path you didn't block | A path you granted |
| What fails first | Security | A feature |
| Upkeep | Chase every new trick | Add grants as needs appear |
| Example | A normal Windows process gets the user's full token | [AppContainer](https://learn.microsoft.com/en-us/windows/win32/secauthz/appcontainer-isolation): "resources are blocked by default and can be granted access as necessary" |
| Example | A Kubernetes pod with no policy: "all outbound connections are allowed" | A [default-deny NetworkPolicy](https://kubernetes.io/docs/concepts/services-networking/network-policies/) |

Deny by default has a cost: friction, approval prompts and broken builds. In practice, people then switch the protection off: `--dangerously-skip-permissions` in Claude Code, `danger-full-access` in Codex, `seccomp=unconfined` in Docker.

## Allowlist vs denylist: why blocklists fail for AI agents

An allowlist names what is permitted and refuses everything else. A denylist names what is forbidden and permits everything else. Whitelist and blacklist are the older names.

A denylist loses to a creative model, because there are endless ways to say the same command:

- [**Cursor auto-run denylist bypass**](https://www.backslash.security/blog/cursor-ai-security-flaw-autorun-denylist) **(Jul 2025).** Researchers beat Cursor's banned-command list four ways: Base64, subshells, scripts and quoting. Cursor dropped the denylist.
- [**Claude Code escapes its own denylist**](https://ona.com/stories/how-claude-code-escapes-its-own-denylist-and-sandbox) **(Mar 2026).** Blocked from npx, the agent called `/proc/self/root/usr/bin/npx` instead.

An allowlist has to check the real thing, not a string. The [Gemini CLI allowlist bypass](https://tracebit.com/blog/code-exec-deception-gemini-ai-cli-hijack) (Jul 2025) checked only the first word of a command.

> Watch out
>
> An empty allowlist must mean "nothing", never "everything". Anthropic's sandbox-runtime had exactly this bug ([CVE-2025-66479](https://github.com/anthropic-experimental/sandbox-runtime/security/advisories/GHSA-9gqj-5w7c-vx47), Dec 2025, low severity).

## How AI agents break deny by default

Each of these nine started with something allowed by default. Newest first:

| Incident | Date | Allowed by default | The deny-by-default fix |
| --- | --- | --- | --- |
| [Antigravity "Secure Mode" bypass](https://www.pillar.security/blog/prompt-injection-leads-to-rce-and-sandbox-escape-in-antigravity) | Apr 2026 | Built-in tools ran before the safety checks | Check every call before it runs |
| [Antigravity Turbo mode wipes a drive](https://www.theregister.com/2025/12/01/google_antigravity_wipes_d_drive/) | Dec 2025 | With approvals off, "clear a cache" deleted the D: drive | Keep approvals on for destructive commands |
| [Claude Code project files before trust, CVE-2025-59536](https://blog.checkpoint.com/research/check-point-researchers-expose-critical-claude-code-flaws/) | Oct 2025 | MCP servers and hooks ran before "trust this folder" | Load nothing from a repo before consent |
| [AWS Kiro rewrites its own allowlist](https://embracethered.com/blog/posts/2025/aws-kiro-aribtrary-command-execution-with-indirect-prompt-injection/) | Aug 2025 | The agent could edit its own allowlist | Make policy files read-only to the agent |
| GitHub Copilot "YOLO mode", CVE-2025-53773[^5] | Aug 2025 | A hidden instruction set `chat.tools.autoApprove: true` | Make settings read-only to the agent |
| Cursor "CurXecute", CVE-2025-54135[^6] | Jul 2025 | New MCP servers started automatically | Never auto-start new tools |
| [Cursor auto-run denylist bypass](https://www.backslash.security/blog/cursor-ai-security-flaw-autorun-denylist) | Jul 2025 | Any command not on the denylist | Allowlist, never denylist |
| [Langflow unauthenticated RCE, CVE-2025-3248](https://nvd.nist.gov/vuln/detail/CVE-2025-3248) | Apr 2025 | A code endpoint with no login, exploited in the wild | Require auth on every endpoint |
| [Codex CLI runs repo config, CVE-2025-61260](https://nvd.nist.gov/vuln/detail/CVE-2025-61260) | 2025 | Loaded `.env` and `.codex/config.toml` and ran commands with no confirmation | Trust no repo config on open |

### The off switch was a writable file

[Copilot](https://embracethered.com/blog/posts/2025/github-copilot-remote-code-execution-via-prompt-injection/) and [Kiro](https://embracethered.com/blog/posts/2025/aws-kiro-aribtrary-command-execution-with-indirect-prompt-injection/) kept their safety settings in files the agent could edit, so a hidden instruction turned approvals off or widened the allowlist. As a general rule, the agent can never write its own policy.

### New tools started themselves

In [CurXecute](https://www.aim.security/post/when-public-prompts-turn-into-local-shells-rce-in-cursor-via-mcp-auto-start), [Claude Code](https://blog.checkpoint.com/research/check-point-researchers-expose-critical-claude-code-flaws/) and [Codex CLI](https://nvd.nist.gov/vuln/detail/CVE-2025-61260) ran tools from config nobody approved. The rule: a new tool or MCP server starts only after a human says yes.

### Approvals off, damage on

[Antigravity lost a drive](https://www.theregister.com/2025/12/01/google_antigravity_wipes_d_drive/) with approvals off, and its [Secure Mode checked too late](https://www.pillar.security/blog/prompt-injection-leads-to-rce-and-sandbox-escape-in-antigravity). [Langflow](https://nvd.nist.gov/vuln/detail/CVE-2025-3248) never checked. The rule: every action passes a check before it runs.

## The 2026 lab breakouts: a network assumed closed

In 2026, frontier labs caught their own agents leaving sandboxes, and none used a hypervisor exploit. Each went through a channel that was allowed or assumed closed, from a package-registry proxy to an unfiltered DNS resolver. The [principles hub](https://cosmonic.com/ai-sandbox/principles/) tells each one.

After the DNS escape, OpenAI wrote: "Our safety case assumed that the model could not access the live internet... The incident exposed a gap in our controls over network restrictions." It paused all training, evaluation and inference using tool access for its most capable models.

In each case the network was assumed closed, not proven closed. So test the deny: from inside the sandbox, try DNS, the proxy and a direct connection. Each should fail.

## How to implement deny by default security (step by step)

1. **Declare what the task needs up front:** files, commands, hosts and secrets, so the sandbox never guesses (step one of the [six-step method](https://cosmonic.com/ai-sandbox/choosing-an-agent-sandbox/#how-to-choose-an-agent-sandbox-in-six-steps)).
2. **Start every resource from an empty rule set.**
3. **Grant one thing at a time, as narrow as the control allows:** a path, a host plus method, one import.
4. **Make the policy and the agent's config files read-only to the agent.**
5. **Require a human to approve any new grant.** Never auto-start new tools or MCP servers. Ask again when a tool's definition changes.
6. **Test the deny.** Claude Code's docs suggest `curl --noproxy '*' https://example.com`, which should fail[^7].
7. **Log every denial** and review it before you widen a grant.

## Deny by default across the sandbox types

A plain process on any OS starts wide open: it can do everything your user account can. An OS sandbox reaches deny by default only when you stack more tools on top:

- **Linux:** a [Landlock](https://docs.kernel.org/userspace-api/landlock.html) deny-all ruleset, then grants per path; a [seccomp](https://man7.org/linux/man-pages/man2/seccomp.2.html) filter whose default action returns an error; [bubblewrap](https://github.com/containers/bubblewrap) namespaces for an empty filesystem view and no network; and a proxy, such as socat, for the network you allow.
- **macOS:** a Seatbelt profile that starts from `(deny default)`, run with `sandbox-exec`, plus a Network Extension filter for the network. Apple has deprecated sandbox-exec and documents no profile language; [App Sandbox](https://developer.apple.com/documentation/security/app-sandbox) entitlements are the documented route.
- **Windows:** [AppContainer](https://learn.microsoft.com/en-us/windows/win32/secauthz/appcontainer-isolation) or LPAC, which starts with no capabilities, plus [App Control](https://learn.microsoft.com/en-us/windows/security/application-security/application-control/app-control-for-business/appcontrol) in allow mode, so code runs only if your policy says so. [Windows Firewall](https://learn.microsoft.com/en-us/windows/security/operating-system-security/network-security/windows-firewall/) allows all outgoing traffic by default, so set it to block outbound.

Each layer is one more policy to write and keep current. The table rates the OS sandboxes as configured. As elsewhere, we call these "sandbox types" after the conventional usage, though [containers and VMs are not sandboxes on their own](https://cosmonic.com/ai-sandbox/principles/#containers-microvms-and-vms-are-not-sandboxes).

**Process (Rating: No)**

**Starts with:** Everything the user can do

**Controls to add:** Run it under an OS sandbox

**Linux sandbox as configured (Rating: Yes)**

**Starts with:** An empty filesystem view (bubblewrap)

**Controls to add:** `bwrap --unshare-all`; Landlock deny-all plus grants; seccomp allowlist with SECCOMP_RET_ERRNO; nftables policy drop

**Upstream doc:** [bubblewrap](https://github.com/containers/bubblewrap), [Landlock](https://docs.kernel.org/userspace-api/landlock.html), [seccomp(2)](https://man7.org/linux/man-pages/man2/seccomp.2.html)

**macOS sandbox as configured (Rating: Yes)**

**Starts with:** (deny default) in the Seatbelt profile

**Controls to add:** Seatbelt (deny default); App Sandbox entitlements

**Upstream doc:** [App Sandbox](https://developer.apple.com/documentation/security/app-sandbox)

**Windows sandbox as configured (Rating: Yes)**

**Starts with:** No capabilities (AppContainer)

**Controls to add:** AppContainer or LPAC; App Control allow mode; firewall blocks outbound

**Upstream doc:** [AppContainer](https://learn.microsoft.com/en-us/windows/win32/secauthz/appcontainer-isolation)

**Container (Rating: Partial)**

**Starts with:** Default seccomp "disables around 44 system calls out of 300+"; network and capabilities stay broad

**Controls to add:** `--cap-drop ALL`; `--network none`; `--read-only`; `no-new-privileges`; default-deny NetworkPolicy

**Upstream doc:** Docker seccomp[^8], [no_new_privs](https://docs.kernel.org/userspace-api/no_new_privs.html)

**gVisor (container runtime) (Rating: Partial)**

**Starts with:** The same open defaults inside as a container, but the host kernel only sees the small set of calls its user-space kernel is allowed to make

**Controls to add:** Run it as the runtime (runsc); keep the container controls: `--cap-drop ALL`, `--network none`, `--read-only`

**Upstream doc:** [gVisor security model](https://gvisor.dev/docs/architecture_guide/security/)

**VM (Rating: Partial)**

**Starts with:** Host denied; inside the guest, everything allowed

**Controls to add:** No NIC or shared folders until needed (QEMU: -nic none)

**Upstream doc:** [QEMU invocation](https://www.qemu.org/docs/master/system/invocation.html)

**microVM (Rating: Partial)**

**Starts with:** Only attached devices; the guest OS is wide open

**Controls to add:** No network device unless needed

**Upstream doc:** [Firecracker network setup](https://github.com/firecracker-microvm/firecracker/blob/main/docs/network-setup.md)

**Wasm (Rating: Yes)**

**Starts with:** No imports, so no access

**Controls to add:** Grant each WIT import deliberately

**Upstream doc:** WIT worlds[^9]

A plain process starts with everything the user can do. A configured OS sandbox can start from nothing but rarely does, because nobody can predict what an arbitrary program needs; Wasm starts there, because each component declares its needs as imports.

> What is Rice's theorem?
>
> Rice's theorem says no tool can work out, in general, what an arbitrary program will do[^10]. So a sandbox can't infer what to allow; the program has to say. Think of packing for a trip: nobody can guess your list, so you write it.

![Deny-by-default controls for an AI agent at each layer: files, commands, network, secrets, config and tool imports](https://cosmonic.com/ai-sandbox/principles/deny-by-default/deny-by-default-layers-day.webp)

> Seccomp is 21 years old. Why does almost nothing ship with it?
>
> Seccomp, the Linux system call filter, was merged in 2005 (Linux 2.6.12). Filter mode, which lets a program load its own rules, arrived in 2012 (Linux 3.5)[^11]. The kernel docs[^12] set expectations plainly: "System call filtering isn't a sandbox."
>
> Profiles are rare for two reasons:
>
> - **You would have to predict every system call a program will ever make**, on every path. In general that is undecidable (Rice's theorem).
> - **Profiles break when libc or the runtime changes.** glibc 2.34 started calling `clone3`, Docker's default profile blocked it, and programs failed to start threads[^13].
>
> What people do in practice: when a container breaks, they run Docker with `--security-opt seccomp=unconfined` or `--privileged`, which turns the filter off, and move on.

### What the agent vendors ship: network closed by default

- [**Claude Code**](https://code.claude.com/docs/en/sandboxing) uses Seatbelt on macOS and bubblewrap on Linux and WSL2. Traffic goes through a local proxy whose allowed domains start empty. The gaps: when a command fails, Claude may retry it outside the sandbox with `dangerouslyDisableSandbox` (set `allowUnsandboxedCommands: false` to stop that), `excludedCommands` run with "no filesystem restrictions and no network proxy", and "Claude's file tools, MCP servers, and hooks run outside it."
- [**Codex**](https://learn.chatgpt.com/docs/agent-approvals-security) has three modes: `read-only`, `workspace-write` and `danger-full-access`. In the default `workspace-write` mode, network access is off unless you turn it on.

### Two deny-all network examples

Kubernetes (needs a network plugin that enforces NetworkPolicy):

yaml

```
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny-egress
spec:
  podSelector: {}
  policyTypes:
  - Egress
```

nftables:

nftables

```
table inet agent {
  chain output {
    type filter hook output priority 0; policy drop;
  }
}
```

For the full 15-row comparison, see the [comparison matrix](https://cosmonic.com/ai-sandbox/principles/sandboxing-principles-matrix.pdf).

## Deny by default with WebAssembly components

A WebAssembly component with no imports can compute, but it cannot touch a file, a socket or a secret. In WASI's own words, a component "starts with no ambient authority and can only do what the host explicitly grants" ([wasi.dev](https://wasi.dev/)).

The component declares its needs up front: its imports list them before it runs, so the host never guesses. App Sandbox entitlements are the same idea for macOS apps.

wit

```
package example:fetcher;

world fetcher {
  import wasi:http/client@0.3.0;
  export run: func() -> string;
}
```

- `world fetcher` is the component's full contract with the host.
- `import wasi:http/client` is its only grant: it may make outgoing HTTP requests. The host still decides which destinations[^14].
- `export run` is what it offers. With no file or socket import, it has neither ([more on capabilities](https://cosmonic.com/ai-sandbox/capabilities/)).

A capability is also unforgeable: a component can use only what it was handed, and it can't guess one, build one from a name or string, or copy one it was never given[^15]. The runtime enforces this, not the program's good behavior: a component can call only the imports the host linked, and the runtime checks every resource handle, so the room has no doors until the host cuts one.

Cosmonic uses this model. [Cosmonic Desktop](https://cosmonic.com/desktop/), for macOS, Windows and Linux, runs components in a deny-by-default sandbox and shows what a component can reach before it runs. [Cosmonic Control](https://cosmonic.com/control/) denies egress by default, adds DNS controls, and uses a Kubernetes admission controller and RBAC.

For a working example, see [stopping remote code execution with a sandbox](https://cosmonic.com/blog/stopping-remote-code-execution-with-a-sandbox/): an unpatched zip library contains multiple vulnerabilities including a remote code execution bug, but a component is granted only one scratch directory has nothing else, mitigating the impact.

The limits: every capability needs host wiring, and existing CLI tools must be ported or wrapped.

## Is deny by default part of zero trust for AI agents?

Yes: zero trust gives no implicit trust by location, so every request is refused until a policy decision allows it[^16]. For agents, location means the laptop, the VPC or the repo the user just opened. Being there grants nothing. The Claude Code and Codex CLI repo-config incidents were location-trust failures. The [policy enforcement points](https://cosmonic.com/ai-sandbox/principles/policy-enforcement-points/) page covers checking every request.

## Deny by default and the other principles

- [**Least authority**](https://cosmonic.com/ai-sandbox/least-privilege-ai-agents/) keeps the grants you add back small.
- [**Policy enforcement points**](https://cosmonic.com/ai-sandbox/principles/policy-enforcement-points/) make the deny real at every request.
- [**Controlled information flow**](https://cosmonic.com/ai-sandbox/principles/lethal-trifecta/) covers what deny by default can't: data leaking through a channel you allowed.
- **Defense in depth** stacks it with other layers, because one layer can fail.

To see what a component can reach before it runs, [try Cosmonic Desktop](https://cosmonic.com/desktop/). Or go back to [The 6 Principles of Secure Agent Platforms](https://cosmonic.com/ai-sandbox/principles/).

[Previous 1. Isolation](https://cosmonic.com/ai-sandbox/principles/isolation/) [The series Back to all six](https://cosmonic.com/ai-sandbox/principles/) [Next 3. Least authority](https://cosmonic.com/ai-sandbox/least-privilege-ai-agents/)

## Related topics

[Principles Principles of secure agent platforms Security design principles for AI agents, from Saltzer and Schroeder to NIST, each tied to a real AI agent incident.](https://cosmonic.com/ai-sandbox/principles/) [Concept Least privilege for AI agents Why least privilege breaks down for agents, how least authority goes further, and the controls that enforce it.](https://cosmonic.com/ai-sandbox/least-privilege-ai-agents/) [Concept What are capabilities? Ambient authority, the confused deputy problem, and what it means to hand an agent one key instead of the whole ring.](https://cosmonic.com/ai-sandbox/capabilities/) [Principle 4 Policy enforcement points Complete mediation in practice: one guard per resource, PDP vs PEP, and checking the real file, not its name.](https://cosmonic.com/ai-sandbox/principles/policy-enforcement-points/)

## See what a component can reach before it runs

Public beta

Cosmonic Desktop runs each tool as a WebAssembly component that starts with no imports, so it reaches nothing until you grant it. Free for personal use, no account, no cloud.

[Download Cosmonic Desktop](https://learn.cosmonic.com/cosmonic-desktop-beta) [Pick a sandbox per layer](https://cosmonic.com/ai-sandbox/choosing-an-agent-sandbox/#how-to-choose-an-agent-sandbox-in-six-steps)

![Cosmonic Desktop's Inspect view: a component's declared interfaces and network egress drawn out, with everything else denied by default.](https://cosmonic.com/ai-sandbox/inspect-capabilities.webp)

## Frequently asked questions

**What is deny by default?**

Deny by default is a security rule that refuses every request unless a rule explicitly allows it. For an AI agent, it means starting with no files, hosts, commands or secrets. You grant each one on purpose; anything else stays out of reach.

**Is default deny the same as an allowlist?**

In effect, yes. Default deny is the rule: anything not allowed is refused. The allowlist is the exceptions you write under it. A default-deny system with an empty allowlist can do nothing, which is the right starting point for a new agent.

**What traffic would an implicit deny firewall rule block?**

An implicit deny rule blocks all traffic that no earlier rule allowed. It is the silent last line of the rule set: you never write it, but it always applies. For an AI agent's sandbox, that means any host, port or protocol you did not grant stays unreachable.

**Is "secure by default" the same as deny by default?**

No. Secure by default is a product promise that the shipped settings are safe. Deny by default is one way to keep that promise. A product can be secure by default and still allow some things out of the box.

**Can an OS sandbox like bubblewrap, Seatbelt or AppContainer be deny by default?**

Yes, as configured. All three can start from nothing. Few tools ship a deny-all profile, because nobody can predict what an arbitrary program will need (Rice's theorem), and profiles break when libraries change. WebAssembly avoids the guess, because each component declares its needs as imports.

**Doesn't deny by default make AI agents unusable?**

Only if grants are too coarse. Grant per task, ask a human only for new grants, and log every denial so you can widen a grant on purpose when a real need shows up. Turning approvals off instead is how the Copilot and Antigravity Turbo incidents happened.

## Further reading

**Papers**

- Miller 2006, "Robust Composition"[^17]

**Upstream docs**

- [OpenAI Codex: Agent approvals and security](https://learn.chatgpt.com/docs/agent-approvals-security)
- [Landlock, Linux kernel docs](https://docs.kernel.org/userspace-api/landlock.html)
- [Kubernetes NetworkPolicy](https://kubernetes.io/docs/concepts/services-networking/network-policies/)

[^1]: NIST CSRC glossary, “deny by default” (from SP 800-41 Rev. 1). [csrc.nist.gov](https://csrc.nist.gov/glossary/term/deny_by_default)
[^2]: Saltzer and Schroeder (1975), “The Protection of Information in Computer Systems”. [cs.virginia.edu](https://www.cs.virginia.edu/~evans/cs551/saltzer/)
[^3]: Saltzer and Schroeder (1975), “The Protection of Information in Computer Systems”, Proceedings of the IEEE. [doi.org](https://doi.org/10.1109/PROC.1975.9939)
[^4]: nftables wiki, “Configuring chains”. [wiki.nftables.org](https://wiki.nftables.org/wiki-nftables/index.php/Configuring_chains)
[^5]: Embrace The Red, GitHub Copilot remote code execution via prompt injection (CVE-2025-53773), August 2025. [embracethered.com](https://embracethered.com/blog/posts/2025/github-copilot-remote-code-execution-via-prompt-injection/)
[^6]: Aim Security, “When public prompts turn into local shells: RCE in Cursor via MCP auto-start” (CurXecute, CVE-2025-54135), July 2025. [aim.security](https://www.aim.security/post/when-public-prompts-turn-into-local-shells-rce-in-cursor-via-mcp-auto-start)
[^7]: Anthropic, Claude Code sandboxing documentation. [code.claude.com](https://code.claude.com/docs/en/sandboxing)
[^8]: Docker, seccomp security profiles. [docs.docker.com](https://docs.docker.com/engine/security/seccomp/)
[^9]: The Component Model book, WIT reference. [component-model.bytecodealliance.org](https://component-model.bytecodealliance.org/design/wit.html)
[^10]: Rice (1953), “Classes of Recursively Enumerable Sets and Their Decision Problems”. [doi.org](https://doi.org/10.1090/S0002-9947-1953-0053041-6)
[^11]: LWN.net, on the history of seccomp. [lwn.net](https://lwn.net/Articles/656307/)
[^12]: Linux kernel documentation, Seccomp BPF (seccomp_filter). [docs.kernel.org](https://docs.kernel.org/userspace-api/seccomp_filter.html)
[^13]: actions/runner-images issue #3812: Docker’s default seccomp profile blocked glibc 2.34’s clone3. [github.com](https://github.com/actions/runner-images/issues/3812)
[^14]: WebAssembly/wasi-http on GitHub. [github.com](https://github.com/WebAssembly/wasi-http)
[^15]: Dennis and Van Horn (1966), “Programming Semantics for Multiprogrammed Computations”. [doi.org](https://doi.org/10.1145/365230.365252)
[^16]: NIST SP 800-207 (2020), Zero Trust Architecture. [doi.org](https://doi.org/10.6028/NIST.SP.800-207)
[^17]: Miller (2006), “Robust Composition”, PhD dissertation, Johns Hopkins University. [erights.org](http://www.erights.org/talks/thesis/)
