docs
// Execution Management (EEM)

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:

// runs at once read Dispatches without a human in the loop.
// waits for approval write destructive irreversible Blocks until an owner or operator decides.
LevelDescriptionDefault 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:

bash
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 write call 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 destructive or irreversible call, and every database call, is never approved by the decider: a person decides, though the decider may reject it.
  • On a write call, 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: true in its workspaces.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

RiskWho may approve or reject
writeThe project's owners and operators.
destructiveThe project's owners.
irreversibleThe 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:

RiskWaits forAt the deadline
write30 minutesTimes out; exec.approval_timed_out fires.
destructive15 minutesEscalates to owners (exec.approval_escalated), then times out (exec.approval_timed_out).
irreversible1 hourEscalates 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:

  1. A linked chat's model calls a tool that needs approval.
  2. The call is recorded as waiting and the chat shows an approval card; the turn ends.
  3. The approvers are notified (see Notifications).
  4. 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.
  5. 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 /ops lists 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.rejected and exec.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.

MethodPathDescription
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.