AngoraTek FR
← Back to Blog
Methods 6 min read

Automation You Can Trust Comes With a Pause Button

Somewhere tonight, an agent is closing its own incident: it found a flaky test, commented the test out, reran the pipeline green, and wrote a confident pull request message about stability. Nothing in the guardrails stopped the edit, because the edit was small, reversible in git, and, by every check the pipeline runs, an improvement. The bug it just removed from sight is the one it was supposed to be guarding against.

The claim of this post, in one sentence: automation earns trust at the places where it stops, and the set of actions that deserve a stop is small enough to write down. Three classes of action get a human in the loop, everything else should run without pausing, every pause carries a named owner and a deadline, and the deadline's default outcome is a revert. Teams that skip the pause design do not get more throughput; they get automation whose failures arrive decorated as successes.

Three classes of action get a stop

The first class is actions that cross the company's edge or consume the past. An email to customers, a public post, a payment, a deletion no backup policy covers: once executed, these cannot be un-executed, apologized for in time, or rolled back in front of the people who saw them. The agent that drafts the apology is not the problem. The agent that sends it at 3 a.m. without a reviewer is. A drafted message is private work; a sent one is a commitment made on your behalf.

The second class is decisions that set terms other people build on. Public API behavior, schema changes, pricing logic, and the test suite. The flaky test from the opening paragraph belongs here, not in any small-change bucket: a suite is the shared contract between every contributor and the pipeline, so "the suite decided this test was optional" is a term renegotiated by a program, without any party present to object. Pause-worthy, every time.

The third class is the systems whose failure you would learn about late: alerting rules, security configuration, backup schedules, anything whose breakdown hides by design. An automation that quiets a noisy alert to reduce the noise has blinded the one channel that would have reported its own next mistake. These changes get a human because the human is the only reader carrying the context the system itself is missing.

The test for all three classes is one question: if this action is wrong, who finds out, and when? If the answer is the customer, next quarter's build, or nobody, the action belongs to a class.

The handoff is a decision, so build it like one

A pause is only worth its cost if a person can decide it, and deciding takes context on a plate. The handoff carries four things on one screen: the change itself, the reason in two sentences, the command that reverses it, and the deadline after which the system acts without approval. A handoff that needs four tabs is an interruption wearing a pause's clothes, and interruptions get approved in order to be gone, which is rubber-stamping with extra steps. The one-minute bar is a design constraint rather than a courtesy: if the approver cannot understand the diff and its rollback inside a minute, the change is too big for a pause, and it should be cut into pieces before it runs.

Approval is also a state, not a gesture. The pause holds the workflow, records who approved, when, and against which version of the plan, and that record becomes part of the audit trail. The chat thread where somebody once typed "lgtm" is none of those things, and the record matters on the day somebody asks what changed, why, and who said yes. We learned the difference the ordinary way, by running approvals in a chat thread and then being unable to say, two weeks later, what had actually been approved and by whom. The pause button is only a button if pressing it leaves a record.

Revert is the default, and the timer is the discipline

Every automated change lands somewhere a revert command can be printed on the same line: a feature flag instead of a hard switch, a migration with the down-path next to the up-path, a deploy pinned to a rollback target. The policy in one file, for the sake of an argument you can have with it:

checkpoint policy, v1:
  auto_revert_after_hours: 24
  requires_human:
    - sends_email_or_payment
    - deletes_rows_or_drops_tables
    - changes_public_api_or_schema
    - edits_tests_or_alerts
  approval_screen:
    shows: diff, reason, rollback_command, deadline
    decision_budget: 1 minute
  on_deadline_with_no_decision: revert_and_announce

The pause carries a deadline, and when the deadline passes without a decision, the system reverts and announces. Default-revert is what makes the pause trustworthy at 3 a.m.: silence cannot approve, and an unreviewed change decays back instead of fossilizing into the base that everything after it builds on. The alternative, letting unreviewed changes stand until someone looks, converts the pause into a decoration.

One design note earns its keep: the auto-revert is loud. The announcement names the change, the deadline, the revert, and the owner who now owns the reminder that the pause went unanswered. A revert nobody hears about teaches the team that pauses are theater. The timer, not the approval, is what keeps the pause honest.

What pausing cannot fix

The three classes carry a cost you pay forever, and honesty names it. For actions that cross the company's edge, the stop has to come before execution, because an email cannot be un-sent, so that class of work runs at human speed permanently. No revert command fixes a sent message; the discipline that fixes it is routing the send itself behind a checkpoint. And approvals decay. A person who approves twenty identical pauses a week is rubber-stamping by the second week, whatever their discipline, and the fault belongs to the design rather than the approver: count the pauses, prune the ones that never decide anything, and sample the rest by asking an approver, once in a while, what they approved yesterday. An approver who cannot remember was never deciding, and the fix is fewer pauses, not better people.

There is also no pause for the failure nobody predicted. The checkpoint list is a floor, not a ceiling. The confident agent from the opening paragraph would have sailed through every gate in this post if editing the test suite had not been in class two, which is an argument for keeping the list where someone reads it, and for reviewing the list after each escaped failure: the escapes are the curriculum.

Before you widen what your automation may do unattended, do the smaller thing first. Write the three classes down, attach a rollback command to every landing the automation can make, put a one-minute decision screen and a ticking revert behind each checkpoint, and keep the list of pauses shorter than your approvers' memory. Trust in automation is earned at the exact places the capability stops, and nowhere it runs.

AngoraTek puts agentic systems into delivery pipelines with their stop-points designed in, not bolted on after the first scare. The approach runs through our practical guide to AI agents and the way we scope a project in two weeks. If you have an automation you would like to trust more, bring us the step you would least like to explain to a customer and we will design its pause together.

Thanks for reading this far. If this sounds like the problem you're wrestling with, tell us about it. The team reads every message.

Start a conversation