Approvals
A person signs off before a tool call changes anything. Every tool declares a risk level in its manifest; a read call runs at once, and every other call waits for an owner or operator to approve it.
Overview
A waiting call is decided in the chat's approval card, on the
Operations page, in the
desktop Approvals screen, in Needs you in the iOS app, from a one-time email link, with
erectl approvals approve|reject, or through the API
(POST /:project_id/v1/exec/approvals/:id/approve|reject).
A decision made in one place shows everywhere else.
Risk Levels
Every tool declares one of four risk levels in its manifest entry. The risk level decides whether the call waits:
read
Dispatches without a human in the loop.
write destructive irreversible
Blocks until an owner or operator decides.
| Level | Description | Default Policy |
|---|---|---|
read |
Observes state without modification (e.g. k8s_get_pods). |
Auto-approve |
write |
Writes data in a recoverable way (e.g. k8s_label_pod). |
Require approval |
destructive |
Destroys data or state that may be difficult to reverse (e.g. k8s_drain_node). |
Require approval |
irreversible |
Cannot be undone under any circumstances (e.g. openstack_server_delete). |
Require approval |
Two gates no setting can lift: destructive and
irreversible calls, and every call in the
database domain, always wait for a person.
Risk levels are ordered read < write <
destructive < irreversible. See the
MCP exec reference for how risk levels
interact with tool dispatch.
Standing Permissions
An owner or operator may let one workspace run one domain's
read or write calls without asking.
Grant it, list the grants, and remove one with erectl:
erectl workspaces grant-auto-approval ws_prodk8s --domain kubernetes --max-risk write
erectl workspaces auto-approvals ws_prodk8s
erectl workspaces revoke-auto-approval ws_prodk8s --domain kubernetes
The workspace argument is the workspace's external id. When an
owner or operator approves a write call, the chat's
approval card and the Operations decision dialog also offer
"Also allow <domain> writes in <workspace> from now on".
Checking it approves the call and saves the same grant.
A standing permission is never offered for, and never covers,
a destructive or irreversible call or
any call in the database domain.
Auto Approvals
An approval policy can be set to auto. A call that waits under it is
first put to the decisions (System 1) model of the workspace the call runs in, the
one the workspace's Decisions setting chooses. No model, or decisions turned off for
that workspace, means no decider.
- A confident approve runs a
writecall with no person. By default the decider must be at least 0.92 sure the call is routine. - A confident reject rejects any call. By default the decider must be at least 0.85 sure the call should not run.
- A
destructiveorirreversiblecall, and everydatabasecall, is never approved by the decider: a person decides, though the decider may reject it. - On a
writecall, anything less certain, or no answer, follows the policy's low-confidence action: keep waiting for a person (the default) or reject. A call still waiting shows the decider's verdict, for example "Decider: unsure, 0.62 approve".
A policy can belong to a project, a workspace or one EEM. A waiting call is tied to the
EEM that will run it, the policy is chosen in the order chat, workspace, EEM, project,
and the call runs only on that EEM: if it is gone, disconnected, paused or no longer
offers the tool, the call fails with pinned_eem_unavailable and you retry it.
A chat policy may be stricter than its workspace's, never looser.
The decider sees the tool, its risk, the workspace's scope and the call's arguments,
with values under keys such as token, password,
secret or key removed; for a write call made in a
chat it also sees the first 200 characters of the request. Each verdict is recorded with
the model and its confidence, consults are billed to your project as System 1 requests,
and a decider approval appears in the exec.approved webhook as an
approver of kind decider. After the decider rejects a call, the
same tool in the same chat waits for a person for ten minutes.
An EEM's operator can refuse decider approvals for a workspace with
decider_approvals: refuse in its workspaces.yaml
(see Configuration files): such a
call waits for a person, and the EEM itself refuses a decider-approved call there.
Autonomous Trust
A coding agent working in its own workspace can run without stopping at every call. Autonomous trust approves a workspace's calls with no person, and it takes two grants, either of which withdraws it:
- The project's owner turns autonomous trust on for the workspace. Only an owner may turn it on; an owner or an operator may turn it off.
- The operator of the host the EEM runs on opts the workspace in with
allow_autonomous: truein itsworkspaces.yaml(see Configuration files). The router cannot set it.
With both, every call in the workspace that needs approval runs as soon as it is made,
destructive calls included. An irreversible call, and every
database call, still waits for a person. Without both, calls wait for a person
or the decider exactly as before, and the EEM itself refuses a call approved by autonomous
trust in a workspace its host did not opt in.
With both, the git tools in the workspace also run what a repository's own configuration names, such as its hooks and filters, for a call autonomous trust approved and for a read. Without both they never do.
Every call autonomous trust approves is recorded as approved by it, with who turned it on and
when, and appears in the exec.approved webhook with decided_by
autonomous and an approver of kind autonomous.
In the Activity tab and a run's detail, such a call reads Autonomous trust
under Decided by, with who turned the trust on and when.
Turning it on and off
The owner's switch is set per operational workspace. Each place shows whether it is on, who turned it on and when, and, for every EEM that declares the workspace, whether its host opted in and whether the trust applies there. Turning it on asks for confirmation first; turning it off takes effect at once.
- Web: Operations, the Policies tab, Autonomous trust.
- Desktop: Approvals, Policies, Autonomous trust.
- iOS, in Advanced: Console, Approval policies, Autonomous trust.
- erectl:
erectl approvals policies autonomous show|on|off --workspace <ws_id>(see erectl approvals).
The host's half is set where the EEM runs: erectl workspaces declare --workspace
<name> --allow-autonomous writes allow_autonomous: true, and
--no-allow-autonomous removes it. On the desktop app, the workspaces sheet's
Allow autonomous trust toggle does the same for this Mac's EEM. An EEM
that cannot check an autonomous grant is listed as such; its calls wait for a person until
it is upgraded.
Who Decides
| Risk | Who may approve or reject |
|---|---|
write | The project's owners and operators. |
destructive | The project's owners. |
irreversible | The project's owners, after typing I approve to confirm. |
In a workspace under autonomous trust, calls below
irreversible outside the database domain need no one.
Approvers see the call's full arguments before they decide. A
member who started the call sees "Waiting for an owner or
operator." (or "Waiting for an owner." for a destructive or
irreversible call) and may cancel it with "Cancel call". An
owner or operator may cancel any waiting or running call, in the
chat or with erectl exec cancel <invocation-id>.
A cancel takes effect at once; a cancelled call does not run.
Timeouts
A call nobody decides times out and does not run:
| Risk | Waits for | At the deadline |
|---|---|---|
write | 30 minutes | Times out; exec.approval_timed_out fires. |
destructive | 15 minutes | Escalates to owners (exec.approval_escalated), then times out (exec.approval_timed_out). |
irreversible | 1 hour | Escalates to owners (exec.approval_escalated), then times out (exec.approval_timed_out). |
Every surface shows how long a call has waited and when its
deadline falls. A timeout never approves a
destructive, irreversible or
database call.
Approval Flow
A tool call from a linked chat:
- A linked chat's model calls a tool that needs approval.
- The call is recorded as waiting and the chat shows an approval card; the turn ends.
- The approvers are notified (see Notifications).
- An owner or operator approves or rejects in the card, on the
Operations page, in the desktop Approvals screen or the iOS app's Needs you, or with
erectl approvals approve. - An approved call runs on the Erebine Execution Manager (EEM) and the chat continues with its result; a rejected, timed-out or cancelled call returns that outcome to the chat.
From a terminal, erectl approvals list and
erectl approvals watch show waiting calls,
erectl approvals show <id> prints one, and
erectl approvals approve <id> --confirm "I approve"
approves an irreversible call. See
erectl approvals.
Notifications
A waiting call reaches the people who may decide it:
- Chat: the approval card in the chat that made the call.
- Operations: the Activity tab on
/opslists the call as it arrives. - Email: one-time Approve and Reject links go to the project's owners and operators (owners only for destructive and irreversible calls), available when the deployment enables one-time approval links; "Email me about approvals" in your settings turns them off for you.
- Browser: turn on "Notify me about approvals" in your settings; clicking the notification opens the call.
- Desktop: turn on "Notify me about approvals on this Mac" in the desktop app's Settings.
- iOS: allow notifications for the app; a call that is not irreversible carries Approve and Reject on the notification.
- Webhooks: each project's signed webhooks carry
exec.approval_requested,exec.approved,exec.rejectedandexec.cancelled, from which a team routes to Slack, PagerDuty or Opsgenie (see Route Approvals to Slack).
A decision made anywhere updates the card, the list, and the notifications.
API Endpoints
Every path is under the project prefix, /:project_id/v1/exec.
| Method | Path | Description |
|---|---|---|
| GET | /approvals |
List approvals (filter by status, risk level). |
| GET | /approvals/stream |
SSE stream of approval events. |
| GET | /approvals/:id |
Get approval details. |
| POST | /approvals/:id/approve |
Approve a waiting call. |
| POST | /approvals/:id/reject |
Reject a waiting call. |
| POST | /invocations/:id/cancel |
Cancel a waiting or running call. |
/approvals/stream is scoped to one workspace, named by the X-Erebine-Workspace header as the workspace UUID or its ws_ id. Without the header the stream sends its connected event and closes. Tool output from a call you may not decide, and did not make, is withheld from its events.