flowsmithonline

the high game

Agents at full autonomy

Once you can get a website out of your head and onto the internet, the next leap isn't a smarter agent — it's a less timid one. This is the lesson most people never reach: how to stop being your agent's bottleneck.

The real bottleneck is permission, not capability

A capable agent that stops to ask "is this OK?" every few steps isn't fast — it's a very expensive intern waiting on you. The work it can do is no longer the limit; your attention is. Every confirmation it requests spends the one resource that doesn't scale: your time.

The core trade: the operator's time is scarcer than tokens. A blind branch (the agent guesses wrong on something undoable-cheaply) costs a few tokens to redo. A stalled session costs you. Asking you to confirm something you could trivially undo spends the expensive resource to save the cheap one. That trade is always wrong.

Reversible vs irreversible — the only line that matters

The whole discipline collapses to one distinction. If being wrong can be cheaply undone, the agent should just do it — and state its assumption in one line. It stops only before the handful of actions where being wrong cannot be taken back.

Just decide and proceed (never ask)

Stop — but only at the irreversible gate

Even at the gate, don't stop early. Do all the reversible prep autonomously — build the diff, stage the fork, snapshot the current state — and arrive ready to execute with one precise question: "Merge X? the diff is Y." Never a vague "is this OK?".

Don't block — park and batch

An agent should never freeze the session waiting on you mid-stream. When it hits something it can't immediately proceed on: first, try a reasonable assumption if the path is reversible. Only if proceeding would be irreversible (or waste real work down a likely-wrong fork) does it park that one item and keep going on everything else. Parked questions come back as one batch at the end — you answer in a single pass. A healthy session ends with few or zero parked questions, because the agent assumed its way through the reversible ones.

The contract — write it down once

None of this should be re-argued every session. It lives in one file — an autonomy contract — that every agent inherits at startup. Here is the spine of ours:

# Autonomy Contract
You act. You do not seek permission to proceed on reversible work.
The operator's time is the scarcest resource — scarcer than tokens.

NEVER ASK — decide and proceed: ordering, decomposition, "is the plan OK",
naming/formatting, anything restorable from git. State the assumption, move on.

HARD GATE — stop ONLY before irreversible actions: merge/deploy, overwrite a
live workflow, delete, schema/DNS, spend money. Even then, do all reversible
prep first and ask ONE specific question.

DON'T BLOCK — park the rare irreversible blocker, continue everything else,
batch parked questions at the end.

POOL DISCIPLINE — while the operator is away, keep working your pool.
Idle-waiting is a failure state.

Make it inherited — one source, every agent

A rule only one agent follows is a sticky note. The trick is propagation:

This is the difference between a clever prompt and an operating system for a team of agents. The contract is the kernel; the import makes it boot with every process; the bus is the signal to reload.

The propagation prompt (exhibit)

Adopting the contract is itself an autonomy test — the agent does it end-to-end without asking you to confirm the reversible steps. The instruction that does it:

Adopt and propagate the autonomy contract. Do this end to end.
Do not ask me to confirm the reversible steps — saving files, editing
CLAUDE.md, drafting the bus message are yours to just do. Pushing and
broadcasting ARE the assigned task; I've authorized them. Report at the end.

1. Save the contract as AUTONOMY.md where shared agent config lives.
2. Wire it into CLAUDE.md so every agent inherits it (import @AUTONOMY.md —
   keep the rules in ONE place, no duplicate that can drift).
3. Commit and push.
4. Broadcast once on the bus: "pull latest, adopt AUTONOMY.md as binding."
5. Adopt it yourself now. You are the first agent under this contract.

Why this is the high game

With a timid agent you spend your day as a confirm-button. With a contract, the agent runs its pool while you're away, brings you a tight batch of genuinely-irreversible decisions, and the throughput is not 20% better — it's a different category. The skill isn't prompting harder; it's deciding once, in writing, where the agent may act on its own — and trusting the line between undoable and not.

The instinct to fight: "but what if it's wrong?" On reversible work, wrong is cheap — git remembers, drafts revert, forks get deleted. You're not removing the safety net; you're moving it to where it actually matters.

Where next