All pages

Autonomy you can trust · Lesson 1.1 · 10 min · Free

Choose a posture

Match how much the agent may do unasked to the task in front of it.

Listen

After this lesson you can look at a task, judge how much damage a wrong move could do and how easily you could undo it, and set the agent's posture, rules and mode to match. You also know which guards stay on no matter what you choose.

Time: 10 minutes · Works on: macOS app.

Autonomy is a dial, not a switch

Every tool call an agent makes either waits for you or doesn't. When it waits, you pay with attention. When it doesn't, you pay with risk. Neither cost is zero, and the right balance changes from one task to the next. Picking one setting and leaving it there is the mistake: either you approve two hundred harmless reads a day and stop reading the cards, or you let the agent run freely on the one afternoon it touches something that matters.

So choose per task, on purpose, before you send the prompt. Three questions are enough.

  1. What is the blast radius? Which files, branches, machines and accounts could this task reach if the agent misread it? A change confined to one worktree is small. Anything that touches a shared branch, a database, a deploy, or a credential is large.
  2. How reversible is it? A file edit is reversible: there is a snapshot and there is git. A force push, a dropped table, a sent email or a paid API call is not.
  3. How much attention can you give it? If you'll be reading along, you can afford more prompts. If you're about to walk into a meeting, you can't, and prompts nobody answers just stall the run.

Large blast radius or low reversibility means the agent should ask. Small and reversible means it can go, provided something checks the result afterwards.

The three postures

TRMNLY gives each project a posture, shown on a chip in the agent header:

  • Approve is the default. Tools that change something wait for your approval. Tools that only read run on their own.
  • Auto-accept runs every tool without asking.
  • Observe is read-only. Writes and commands are blocked outright.

Map tasks onto them like this:

Task Posture Why
Learn an unfamiliar codebase, triage a bug, review a PR Observe Nothing needs to change, so nothing should be able to
Ordinary feature work in your main checkout Approve, plus standing rules You want to see edits land, but not approve every ls
A mechanical change in its own worktree, with tests to check it Auto-accept, with a few tools carved out Small radius, fully reversible, verified by tests
Anything near production, credentials, or a shared branch Approve, reading every card Irreversible actions need a human decision each time

Fight approval fatigue with narrow rules

The real danger of Approve isn't the clicking. It's that after the fortieth identical card you stop reading them, and the forty-first, the one that matters, gets the same reflexive yes.

The fix is to turn repeated safe approvals into standing rules, so the cards that remain are the ones worth reading. Make each rule as narrow as it can be and still stop the repetition. "Allow writes in src/parser/" is a good rule. "Allow every tool" is just Auto-accept with extra steps.

The reverse also helps. On Auto-accept, single out the one or two tools whose mistakes are expensive, such as bash or browser navigation, and make those ask anyway. You keep the speed on everything else.

A worked example

You want the agent to rename a logging module used in about forty files.

  • Blast radius: large in file count, but confined to one repository. Put it in its own worktree and the radius is one branch nobody else uses.
  • Reversibility: complete. Every edit is a file change, and the branch can be thrown away.
  • Attention: you'd rather not approve forty edits one by one.

So: create a worktree, switch the project to Auto-accept, and make bash always prompt so a stray command can't run unseen. The brief tells the agent to finish by running the test suite. You read the diff once at the end instead of forty times along the way.

Now change one fact: the module is also imported by a deploy script that runs on merge to main. The edit is still reversible, but merging it isn't, so the merge step goes back to Approve, and you review the diff before it happens.

The floor you can't lower

Some guards fire whatever posture you choose, and you should plan around them rather than fight them:

  • Destructive commands. The first time in a session that the agent tries an irreversible command such as rm -rf, git reset --hard, git push --force or DROP TABLE, you get a prompt, even on Auto-accept.
  • Protected branches. On main, master, prod, production, release or any release/ branch, irreversible commands need two confirming clicks within 8 seconds.
  • Always prompt. A tool you've flagged this way asks even on Auto-accept.

If a run stops on one of these, it's working as designed. The posture you chose decides everything above that floor.

Do it in TRMNLY

  1. Cycle the posture. Click the posture chip in the agent header, or press ⇧⇥ in the composer. Watch it move through Approve, Auto-accept and Observe. Posture is saved per project, so set it each time you switch to a task with a different risk.
  2. Start a review in Observe. Set Observe and ask the agent to explain a module and list its risks. Try asking it to fix one. The write is blocked, which is exactly what you want while you're still deciding what to change.
  3. Write a narrow rule. Switch to Approve and ask for a small edit inside one folder. When the approval card appears, open Always… on the card and choose Allow this directory. The next write in that folder runs without a card. A write elsewhere still asks. A rule on a folder never covers a sibling with a longer name, so a rule on proj doesn't reach proj-secrets.
  4. Carve out a risky tool. Click the shield icon at the top right of the agent sidebar to open the Safety panel, open the Tools tab, and turn on Always prompt for bash. Now set the posture to Auto-accept. File edits run freely, and every shell command still waits for you.
  5. Lock the session for a sensitive conversation. In the Safety panel's Session tab, turn on Session read-only. It blocks every approval-gated tool for this chat only and resets when you switch chats. Use it when you're pasting in production logs and want analysis, not action.
  6. Rehearse commands with a mode. Open the gear menu, choose Project agent settings…, and set Mode to Dry run (echo commands). Shell commands come back as echoes instead of running, and the chip reads Dry-run. File writes still ask and still happen. Set Mode back to Full access when you're done. The next lesson covers rehearsal in depth.
  7. Set limits for CLI agents too. Claude Code, Codex and Gemini running as a CLI harness don't pass their own edits through TRMNLY's approval cards. Set their level in the gear menu's CLI agent section: Read-only, Accept edits (default) or Full access (no sandbox). Observe or dry run forces them to Read-only.
  8. Know your brake. ⌘. stops the current turn. ⇧⌘. stops the turn, cancels pending approvals and locks the agent until you press Resume. Use it the moment a run looks wrong, then work out why.

Check yourself

  • For your next three tasks, you can name the blast radius, the reversibility and the posture you'd pick, and say why.
  • You have at least one Always… rule scoped to a directory, not a whole tool.
  • On Auto-accept, a bash call still produced an approval card because of Always prompt.
  • You can list the guards that fire even on Auto-accept.

Go further