# Modes

A mode decides one thing: whether agents must prove their checks ran. The shared context stays the same either way. Set it with `brigadestack work mode set strict`, `observe` or `off`.

**Version note.** 0.31.0, the current release, has two modes under older names: `engineer` for strict and `yolo` for off. Observe arrives in the 0.32.0 beta, which prints the new names and still accepts `engineer` and `yolo` as aliases. The output below is from the 0.32.0 beta.

| | Strict (default) | Observe (0.32.0 beta) | Off |
|---|---|---|---|
| Work brief at session start | yes | yes | yes |
| Memory recall and `memory search` | yes | yes | yes |
| Backend messages | yes | yes | yes |
| Handoffs | when the session learned something durable | when you ask for one | when you ask for one |
| Tests, linters and builds | through `brigadestack work verify run`, with a check record | run raw, noted by hooks where the tool supports it | run raw, no record |
| A session that changed code can finish | only with a check record | always | always |
| Skill and card scores | keep moving | stop moving | stop moving |

## Strict

Strict is the default for new installs. The hooks send tests, linters and builds through `brigadestack work verify run`, which runs the real command and records its exit code and the tree it ran on. If an agent runs a check raw, the hook stops it and shows the right form. A session that wrote code cannot finish until a check record exists. See [Tasks, claims and checks](/docs/concepts/tasks-claims-checks).

## Observe

**0.32.0 beta.** Observe blocks nothing. Agents run checks raw, and where the tool's hooks allow it (Claude Code and Codex) BrigadeStack notes each raw check in private per-user state. `brigadestack work checks` then reports first attempts by tool and model as passed, failed or unknown. These notes are observed, not independently verified, and they are separate from signed check records. Not in 0.31.0.

## Off

Off keeps the shared context and drops the enforcement. Agents run checks raw and finish without a check record or a handoff. `brigadestack work verify run` still works by hand. Use it for a scratch repo or a prototype where check records slow you down.

The cost is evidence. Nothing records which checks ran or with what exit code, so skill and card scores stop moving, and `brigadestack doctor` can no longer flag a session that edited code without a test.

## Set or switch the mode

Pick the mode when you wire a repo, or switch at any time:

```bash
brigadestack init --target . --depth repo --harnesses claude --off
brigadestack work mode set off --target .
brigadestack work mode set strict --target .
```

```text receipt="brigadestack work mode set off --target . · exit 0"
work mode: off; safety rails: on (~/my-app)
```

`brigadestack init ... --strict` also switches an install back to strict. `brigadestack work mode show`, `brigadestack status` and `brigadestack doctor` print the current mode. The mode is stored per target in `.brigade/config.json`, and the hooks check the mode of the repo being written to. Older names still work as input: `engineer` and `enforced` mean strict, and `yolo` means off. On 0.31.0, use `--yolo`, `--engineer` and `work mode set engineer|yolo`.

## Safety rails

Safety rails are a separate switch, on in every mode. They cover the content guard, secret scanning and the pre-push publication checks.

```bash
brigadestack work rails off --target .
brigadestack work rails on --target .
```

Turning rails off prints exactly what stops being checked:

```text receipt="brigadestack work rails off --target . · exit 0"
warning: safety rails are off for ~/my-app. Brigade's pre-push hook no longer scans for secrets, credentials, private hosts, or private paths before a push, and the history scan of pushed commits is skipped. Guard policies and baselines are unchanged; `brigade work rails on` restores the previous checks.
work mode: strict; safety rails: off (~/my-app)
```

The rails setting is per user and per repo. It lives in your own Brigade config directory, outside every repository, so a pushed commit cannot disable leak checks for someone who clones it. Run the command from the repo root, because the pre-push hook checks the root.