> ## Documentation Index
> Fetch the complete documentation index at: https://docs.getunbound.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# What Each Default Protects

> Every default policy mapped to the threat it stops, and what it deliberately leaves alone

> [!NOTE]
>
> **Companion to [Recommended Starting Policies](https://docs.getunbound.ai/playbook/recommended-starting-policies)**, covering what each default stops and what it leaves alone. See also [Threat Model](https://docs.getunbound.ai/playbook/threat-model) and [Tool Policy Examples](https://docs.getunbound.ai/playbook/policy-examples).

Your AI coding agents can run anything a developer can. Almost all of it is work you want
them doing. A thin slice is damage you can't take back. This page maps every default policy
to the thing it stops, and shows where the line falls between blocking it and keeping
a log.

## Block or Audit

Every default ships in one of two modes.

> [card] Block
>
> Irreversible, and nothing a developer legitimately needs to do. A one-way door.

> [card] Audit
>
> Routine, but worth a record. Log it silently and learn your baseline before you add any
> friction.

> [!NOTE]
>
> The defaults use only **Block** and **Audit**. **Warn** is available when you author your own
> policies, but its behavior depends on the coding agent, so it isn't a reliable choice for a
> baseline that has to hold everywhere. See
> [Recommended starting policies](https://docs.getunbound.ai/playbook/recommended-starting-policies) for where Warn fits.

> [!NOTE]
>
> In the recommended pack, Block is reserved for irreversible or production-scoped actions: 23 of
> the 49 rules, each narrowed to one operation or target. Everything else is logged and keeps running.

## The threat map

Six things can go wrong when an agent runs commands for you. Every default policy belongs
to one of them.

| Threat layer | What goes wrong | Default mode | Why that mode |
| - | - | - | - |
| **Privilege & identity** | Agent rewrites who-can-do-what, or reaches production as `root`, and now owns the environment |  Block | Once the trust boundary moves you can't move it back |
| **Secrets & credentials** | Agent reads, leaks, or deletes a live key |  Audit,  Block on delete | Devs touch secrets daily, so log it rather than block it. Deleting one can't be undone, so stop it |
| **Production blast radius** | Agent drops a prod database or tears down a prod service |  Block | One command, one outage. There is no undo on production |
| **Data exfiltration** | Agent uploads source or sensitive output somewhere it shouldn't |  Audit | The legitimate and the malicious look alike, so you want eyes, not a wall |
| **Source & supply chain** | Agent pushes straight to `main`, skipping review and overwriting shared history |  Block on `main`,  Audit on provisioning | A direct write to `main`/`master` can't be cleanly undone. Provisioning is routine, so just log it |
| **System integrity** | Agent deletes or rewrites core system files |  Block | Corrupting `/etc` or `/usr` breaks the machine, and it's never a normal coding step |

Most of those layers can block, and most blocks are narrow: production targets,
a push to `main`, the core system paths. The thousands of ordinary commands in those same families never stop.

***

## Privilege & identity

An agent that can SSH in as `root`, attach an IAM policy, or edit Kubernetes RBAC isn't just
running a command. It's rewriting the rules about who gets to run commands at all. Once that
boundary moves, every other control becomes negotiable.

**What fires:** SSH as `root` · SSH to production hosts · the IAM grant operations that rule
names — attaching or inlining a policy, an IAM policy binding, an Azure role assignment or
definition, an assume-role policy update, a new policy version, a permissions boundary, a
bucket policy · Kubernetes RBAC changes.

**Mode:  Block.** These are one-way doors with no real place in a coding loop. A developer
who actually needs them does it deliberately, outside the agent. Blocking them costs the team
nothing and closes the highest-leverage path an attacker has.

> [!NOTE]
>
> The pack governs how an agent **reaches** a privileged boundary — remote access as `root`, and
> changes to IAM or RBAC. Local `sudo` is audited, not blocked: it is logged and still runs. If you want it stopped too,
> add a `custom` policy matching the whole command, which enforces even when a command can't be
> classified.

## Secrets & credentials

The agent doesn't need to hack anything. You ask it
to debug a config, it reads your `.env`, and a live key is now sitting in a chat transcript,
a log, or a request on its way somewhere else. The risky prompt almost never says "leak my
secret." It says:

> *"I need to set up admin settings. Parse the local `.env` file and convert the contents
> into a JSON block."*

**What fires:** Secret retrieval · Vault access · Sensitive env-var exposure · Secret
creation/update · API key/token generation · **Secret deletion, removal, disable, archive or rotation** (an agent cannot rotate a managed secret by default, so rotation stays a human step).

**Mode:  Audit, with one exception.** Reading secrets is part of daily work, so the defaults
log it rather than interrupt it: you get the signal, and nobody is blocked. Deleting a secret
is different. It can't be undone, so it ships as  Block.

## Production blast radius

The distance between "deploy to staging" and "drop the prod database" is one flag, one
context, one typo. An agent moving fast won't feel the difference. You will.

**What fires:** Production cloud destruction · Deployment to production · kubectl apply and
context-switch to prod · Production database writes · Production container operations.
Blocked everywhere, not only production: database DROP, TRUNCATE and DELETE, container stop, kill and removal, namespace deletion.

**Mode:  Block.** The production rules are scoped to `*prod*`, so the block lands on the blast radius, not on the
command: `kubectl apply` against staging is yours to do all day, and against
production it is stopped. The blocks listed as "everywhere" above apply in any environment.

## Data exfiltration

Source code, query results, and environment dumps leaving for some external destination.
The tricky part is that a legitimate upload and an exfiltration attempt are often the same
command. A wall here breaks real work and trains people to route around you.

**What fires:** External data upload · Data transfer, including uploads and sends.

**Mode:  Audit.** You want visibility, not a block that punishes the many uploads that are
perfectly fine. Watch the pattern first, then tighten where your own data tells you to.

## Source & supply chain

Two different risks live in this layer. The first is integrity: a direct push to `main` or
`master` skips review and can overwrite shared history you can't rebuild; a force push is blocked on any branch. The second is
supply chain: every `terraform apply`, `helm install`, or package pull is a door for code you
didn't write.

**What fires:** Direct push to `main`/`master` · Git force push (any branch) · Terraform apply · Helm install and upgrade ·
EC2 instance launch · Container image push.

**Mode:  Block on pushes to `main` and on force pushes,  Audit on provisioning.** A push straight to `main` or
`master` is the irreversible one, and a force push can rewrite shared history on any branch, so both stop. Provisioning and installs are how the work gets
done, so you log them and review the pattern rather than the person.

## System integrity

Deleting files under the system roots (`/etc`, `/usr`, `/var`, `/opt` and the rest), or rewriting files under the core ones (`/etc`, `/bin`, `/sbin`, `/lib`, `/boot`, parts of `/usr` and `/var`), corrupts the machine
itself, the layer everything else runs on.

**What fires:** System file deletion · System file modification.

**Mode:  Block.** No normal coding task rewrites core system files through an agent. Easy
call.

***

## Why the pack audits more than it blocks

If your first instinct is to block all of it, look at who you'd actually be slowing down.
The agent runs hundreds of safe commands for every dangerous one. Block everything and you
tax all of that work to catch the rare event, and you teach developers to switch the
guardrail off.

Audit-first flips that: the safe majority keeps moving, everything risky leaves a trail, and
Block stays reserved for the short list of things with no undo and no legitimate use — which
is why the shipped pack is roughly half Block and half Audit, and uses no Warn at all.

> [!NOTE]
>
> **Warn is an authoring choice, not a default, and it is not a security boundary.** What a
> developer sees depends on the agent: Claude Code, Copilot, Cowork and Pi show a confirmation;
> on Cursor the command runs with no Unbound prompt; on Augment Code the prompt is left
> to Augment's own tool-permission settings; Codex and OpenClaw stop the command
> outright. A headless Claude Code run has no prompt to show, so Warn allows the command
> through unless your organization has set the headless Warn action to Block; a headless Pi run blocks it. Use **Block**
> where an action must not run, and **Require Slack Approval** where you want a Slack
> confirmation step (sent to the developer by default). Full detail in [Actions](https://docs.getunbound.ai/policies/tool-policies.md#actions).

## The maturity ladder

Roll the pack out in order.

**1. Audit, to learn**

Seed the pack and watch. Every high-risk family is logged, so you see what your agents
actually do before you change anything.

**2. Tighten what the data justifies**

Read a few days of matches. Use Preview Impact to see exactly what a change would have
caught, then promote the policies that earn it — and relax any that are noisy against how
your team actually works.

**3. Block, to close the one-way doors**

Turn on block for the irreversible set: prod destruction, secret deletion, direct pushes
to `main`, and system files. By now you've seen the data, so there's nothing to be
surprised by.

## How to read a policy

Every policy reads as one sentence: **when** a kind of command runs, **if** it matches a
condition, **then** take an action. The editor is laid out in exactly those three steps.

| Step | Field in the editor | What goes there |
| - | - | - |
| **When** | Command Family | The umbrella the command belongs to, such as Cloud Secrets or Container Operation |
| **If** | Match Against, then Pattern | Pick one detail of the command to look at, then the value to match (a glob like `*prod*` or an exact string like `get-secret-value`) |
| **Then** | Action | Audit, Warn, Block, or Require Slack Approval |

The choices under Match Against change with the family you picked, so a database policy
offers different details than a secrets policy. You can match a whole family, but you rarely
need to. Start with one detail, so the policy fires on what you mean and leaves the rest
alone.

## Make it surgical

You don't have to choose between blocking a whole family and blocking nothing. The Pattern
field lets one policy fire only on the exact case you care about. You leave developers
all the room they had, and take away only the one action you can't allow.

Take container operations. You want developers building, running, and inspecting containers
freely, but opening an interactive shell inside a running container is the risky one. So you
don't block the whole family. You write one narrow policy:

* **When** (Command Family): Container Operation
* **If** (Match Against): Operation
* **If** (Pattern): `exec`
* **Then** (Action): Block

Everything else in the family stays open. `run`, `push`, and `cp` work all day; only `exec`
is stopped. The family gives you broad coverage with one rule, and the Pattern carves it
down to the single action you mean.

Seed the whole pack in audit, read the first week, and promote with confidence.

## A block the agent reads

Every block, and every warn, carries a short message you write, and it reaches the coding
agent itself, not just the person at the keyboard. Tell the agent why the action is
off-limits and it changes course on its own.

> [card] [Want prompts to test each policy?](https://docs.getunbound.ai/playbook/policy-examples)
>
> The policy examples page has a ready-to-run prompt for every policy, so you can watch
> each one fire before you trust it.

> [card] [Ready to roll out?](https://docs.getunbound.ai/playbook/recommended-starting-policies#go-live)
>
> Back to the three-step go-live →


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.