Auto Mode: How an Agent Decides What It May Do Alone
It's 02:40. An investigation on staging is done, and the agent has two fixes ready. One restarts a stuck worker pod. The other deletes an old RDS snapshot to free backup quota. Both are probably right. The restart can be undone in a minute, and the delete can't. What's open is whether anyone needs to be awake for either.
Ask for a person's approval on everything and you've rebuilt the pager with extra steps. Approve nothing and you've handed production to software that has never been on call. Neither is an answer a senior engineer would sign off on.
Auto Mode answers it per write, not per tool. Every change an agent wants to make passes a fixed blocklist, then your team's Rules, then an AI judgment of whether it matches what was asked. Anything destructive or unclear waits for a person. In the app this lives under Approvals, and Auto is one of its two modes. It's the trust layer that lets Frontier Investigation Agents act at 02:40 without anyone handing them the keys.
Why the usual approaches break
Approve everything. Every write pauses for a click. People stop reading the cards and click through. The control turns into a ritual, and the ritual is the risk.
Allowlist by tool. Mark a tool safe and every call to it runs. But a tool isn't safe or unsafe. Creating a GitLab issue and deleting a project can sit behind the same connection. An allowlist can't see intent.
Trust the prompt. Tell the agent to be careful and hope. A system prompt is advice. It doesn't stop a call.
What's missing is a decision per call: does this write match what the person asked for, and what happens if it's wrong?
How a write is decided
Reads always run. A write is any agent call that changes a connected system: an API call through a connection, a cloud or cluster CLI such as aws or kubectl, a remote program such as ssh or psql, a Git push, or a command that sends a stored credential, such as curl with $STRIPE_API_KEY. Every write passes four steps in order, and the first step that gives an answer decides.
01Blocklist
Always blocked
A built-in list that never runs, whoever asks.
02Rules
Allow, Ask, Deny
Decisions your team accepted, one kind of write each.
03Mode
Manual or Auto
Settles every write no Rule decided.
04Approver
A person answers
Default approvers, or the group a Rule names.
Always blocked is a built-in list of calls that never run: stopping CloudTrail logging, closing an AWS account, deleting the kube-system namespace. No person, Rule or override can change that.
Rules are decisions your team made once. Each names one kind of write and says Allow, Ask first or Deny.
The Approval mode handles every write no Rule settled. It's Manual or Auto, and it can differ by run type.
Who approves decides which people can answer when a write waits.
Manual and Auto
01Manual
A person approves
- Every writeWaits for a person before it runs
- Allow RulesStill ask a person
- Ask first and DenyStill apply
For writes that must always wait
02Auto
Each write is judged
- Your RulesDecide first, once enforcement is on
- AI judgmentAllows a safe write that matches the request
- Everything elseWaits for a person, or is refused
The default for new workspaces
Manual asks a person before every write, including one an Allow Rule covers. Ask first and Deny Rules still apply. It's the mode for writes that must always wait for someone.
Auto runs three steps. Your Rules decide first. Then AI judgment can allow a safe write that no Rule covers, and you can switch that step off. Anything still not allowed either waits for a person (Ask me) or is refused (Refuse). That gives four combinations:
| Auto choice | If still not allowed | Good for |
|---|---|---|
| Rules, Ask me | Asks a person | Only accepted Rules run writes alone |
| Rules, Refuse | Refused | Unattended runs with a tight, known set of writes |
| Rules + AI, Ask me | Asks a person | Most teams. The default for new workspaces. |
| Rules + AI, Refuse | Refused | Unattended runs. The default for Automations. |
The defaults follow who's around to answer. A chat has a person in it, so it asks. An Automation often runs with nobody watching, so it refuses a write instead of waiting forever. Optimize and Review runs have no one to answer at all, so Ask me becomes Refuse there.
You can set a different mode per run type (Chat, Resolve, Optimize, Automations, Review), per Automation, and per chat. The most specific setting wins, even when it's looser than the workspace.
How AI judgment draws the line
AI judgment allows a write that matches what you asked for and stays within that scope. Back at 02:40, if the run was asked to get the staging worker healthy, the restart matches the request and can run. Deleting a snapshot is destructive, so it waits for a person, and a destructive write that waits also raises a High alert in your notification channels.
An unclear write goes to a person too. And if AI judgment can't finish its check, it never allows the write.
That's the difference from an allowlist. The same tool can get different decisions depending on what you asked for and what the call would do.
Rules: decisions you make once
A Rule names a kind of write: the operations (AWS uses IAM action names, so ec2:StopInstances, with * as a wildcard), the connections, the run types it covers, and an optional expiry. When several Rules match one write, Deny beats Ask first, and Ask first beats Allow.
Agents propose Rules as they work, and nothing changes until a workspace Admin accepts one. You can also ask for a Rule in plain words:
/create-policy Let agents stop and start EC2 instances on aws-staging without asking. Keep everything else on that account as it is.
/create-policy Always ask the On-call SRE group before any rds:Delete* call on production.
Or type /find-rules to start a check-up. CloudThinker reads your connections, Optimize findings, incidents, alerts and approval history, then proposes Rules for you to accept or dismiss.
Two guards keep Rules honest. A Rule never matches a read, because reads always run. And an Allow Rule never matches a call CloudThinker can't identify, such as a command that builds its arguments at run time.
One thing to know before you rely on them: Rule enforcement is off by default, and CloudThinker turns it on per workspace. Until then, Rules record what they would have decided, and the Approval mode alone decides each write.
Answering an approval
When a write waits, the chat shows a card naming the action and the connection it touches.
| Button | What it does |
|---|---|
| Approve | Runs this one call |
| Approve for… | Runs it and lets the same operation on the same connection run without asking, for 1 hour, this incident, or 30 days |
| Approve and draft rule | Runs it now, and a side chat drafts a Rule for you to accept |
| Decline | Refuses the call. Tell the agent why, so it can try another route. |
| Break glass… | Runs one call a Deny Rule refused, once. Only the workspace owner and Admins see it, and only when break-glass is on. |
A delete, or any call in Manual, never offers the timed option. You can require a second approver so nobody approves their own run, and route a kind of write to a named group, such as DBAs for database deletes. In Google Chat you can approve from the card. In Slack and Teams, the card links to the web app.
The design decisions
Decide per call, not per tool. Intent and scope live in the call, so that's where the decision belongs.
Fail toward a person. A check that can't finish never allows. An unattended run refuses instead of hanging. An Allow Rule can't match a call it can't identify.
Some lines don't move. Always blocked holds against every mode, Rule and person. A Deny Rule can be marked so that not even break-glass overrides it.
The credential is the ceiling. No decision lets an agent do more than its connection's credential allows, and a connection with Allow writes off refuses every change. More in Where Your Keys Live.
Every decision is visible. The card and its outcome stay in the conversation. The Approvals Activity tab shows what each Rule decided, and on Scale plans and above, Audit Logs record approval decisions, including the ones AI judgment granted.
Honest limits
- Rule enforcement is off until CloudThinker turns it on for your workspace. Until then, choose Manual for writes that must wait for a person.
- AI judgment is a model. It weighs goal and scope, and judgment can be wrong. That's why destructive and unclear writes go to a person.
- A chat pick can loosen a Manual workspace. The admin control is the Let people pick AI judgment for one chat setting: turn it off, and every mode a chat can pick either asks a person or refuses.
- A few connections decide writes in their own connect form and skip Approvals entirely. ClickHouse is one: with writes allowed, changes run with nobody asked. Use a read-only database user there.
- On a custom MCP server, a tool whose name contains a read word such as
getcounts as a read and runs without asking, unless the server marks it destructive. - Commands that act only on a connected machine or in the CLI's local tools, such as
rmor a local file write, may run without asking.
Getting started
Open a chat in a staging workspace, check the approval control in the prompt box, and try one write that matches your request and one that doesn't:
"Restart the checkout deployment in the staging cluster."
"Delete last month's snapshots for the staging database."
"Explain why that last action needed my approval."
Compare what runs alone and what stops, then read the Auto Mode page for how teams roll it out.



