Skip to content

Blog

Every automation needs a scoped, reversible sandbox

Teams design what their automations do and neglect where they run. A written blast radius, a narrow scope and throwaway environments decide whether you can leave an automation unattended.

Written by

Agent security and risk

Published: 28 July 2026 Updated: 2 min read

Most teams can describe the automations they want to run: a reviewer, a verifier, an incident responder. Far fewer can tell me what each one is allowed to touch. That answer decides whether the line is safe.

You would not hand a new hire the production database keys on day one. Not because they are malicious, but because they do not yet know what is fragile, and a confident mistake reaches too far. An automation is the same. It needs an environment scoped to what it actually does, and a way to undo what it did. Here is how we build that into ours.

Write down the blast radius

Start with a written blast radius. For every automation, one sentence: in the worst case, what can this thing damage? If you cannot answer that, you do not understand the automation well enough to run it unattended.

Scope the environment to the job

Scope the environment to the job, not to convenience. A PR reviewer needs to read the diff and the codebase. It does not need write access to production. Give each automation the narrowest environment that lets it finish, and nothing past that. Our default is read-only, and write is earned per task.

Make every action reversible

The automation works on a branch, in a throwaway checkout, in a container, never on the thing that matters. If a run goes wrong, we discard the environment instead of repairing the damage. A throwaway environment is cheap. An incident is not.

Keep automations apart

Two automations sharing one environment means one bad run can corrupt the other. Separate checkouts and separate scopes keep the blast of one inside that one.

Put a hard boundary on irreversible steps

Some actions do not reverse: a deploy, a payment, a message to a customer. Those do not run inside the automation’s own authority. They cross a boundary, a human approval or a hard gate, every single time.

Give the environment the same design hour

Teams spend their design time on what the automation does. The environment it runs in gets whatever is left over. Scope and reversibility deserve the same hour, because they decide whether you can walk away from the thing.

You can see these rules at work in the software factory built in public at software-factory.dev (opens in a new tab).

Pick one automation you run today. Can you name its blast radius in one sentence, and could you throw away its mistakes instead of repairing them?

Further reading

  1. In a regulated enterprise, the committee is the AI bottleneck Code generation is solved. In a regulated enterprise the constraint is the approval process, so the fastest path to adoption is one that needs no new tool approved. 1 min readShort post
  2. Vouch for the harness, not for its output Code review cannot keep up with agent output. Open source maintainers already admit contributors instead of reviewing contributions, and in an agentic factory the contributor to admit is the harness. 1 min readShort post
  3. A vibecoded SaaS leaked user data because nobody owned the design A production SaaS built by vibe coding failed in four different ways with one root cause. What survived shows why AI-generated code needs someone who owns the system design. 1 min readShort post

All 6 posts on Agent security and risk

ClientsClient work

Scaling needs named owners

Coding agents scale across teams when named people own the platform, the team practice, the guardrails, and the measurement. Rollout & scale is where that ownership is built and handed to internal owners, in your stack.

Training on this topic: Agentic Engineering Security for Development Teams
See Rollout & scale

Want to check one team first? The self-check: twelve yes or no questions, three minutes, instant result, no account. Take the self-check