Skip to content

Request Approval Policy

By default, any organization admin or super_admin can approve or deny any request, including their own, and nothing is approved automatically. An optional [approvals.<role>] section in the platform TOML config changes that per requester role: who may decide that role’s requests, whether the requester may decide their own, and whether the role skips human review entirely.

The policy covers every request kind that shares the approval lifecycle: data access, MCP proxy access, and skill access. It is global to the deployment. Roles are the caller’s and the requester’s membership roles in the active organization; platform-admin status does not bypass the policy.

Put the section in a10e.toml, or, on a bundle host, in the operator overlay at /etc/a10e/config.toml so it survives upgrades (see Persistent Platform Configuration).

[approvals.user] # requests created by members with role "user"
approvers = ["user", "admin", "super_admin"] # roles that may approve or deny
allow_self = false # the requester may not approve their own request
[approvals.admin]
approvers = ["admin", "super_admin"]
allow_self = false
[approvals.super_admin]
mode = "auto" # approved on creation, no human approver
Key Meaning
approvers Roles that may approve or deny this role’s requests. Required unless mode = "auto".
allow_self Whether a requester who holds an approver role may decide their own request. Defaults to true.
mode "manual" (default) or "auto". "auto" cannot be combined with approvers or allow_self.

Rules:

  • Valid roles are user, admin, and super_admin. Names are case-insensitive and trimmed.
  • A role with no [approvals.<role>] table keeps the built-in rule: approvers = ["admin", "super_admin"], allow_self = true.
  • Whoever may approve a request may deny it; the gate is identical.
  • There is no environment-variable form. The policy lives in TOML only.
  • With layered config, an overlay [approvals.<role>] table replaces the shipped table for that role whole (it is not merged per key). Roles the overlay omits keep the shipped rule.
  • The policy is read once at startup. Restart after changing it.

Startup fails with an error naming the offending table if the section:

  • names a requester or approver role other than user, admin, super_admin;
  • uses a key other than mode, approvers, allow_self;
  • lists no approvers in manual mode;
  • combines mode = "auto" with approvers or allow_self;
  • uses a mode other than manual or auto.

An invalid policy never falls back to the default; fix it and restart.

Only admins approve; nobody self-approves:

[approvals.user]
approvers = ["admin", "super_admin"]
[approvals.admin]
approvers = ["admin", "super_admin"]
allow_self = false
[approvals.super_admin]
approvers = ["super_admin"]
allow_self = false

Peer review among users (users approve other users, not themselves):

[approvals.user]
approvers = ["user", "admin", "super_admin"]
allow_self = false

Low friction: user requests are auto-approved, admins review each other:

[approvals.user]
mode = "auto"
[approvals.admin]
approvers = ["admin", "super_admin"]
allow_self = false

When the requester’s role is in auto mode, creating a request (POST /v1/requests, /v1/requests/mcp-access, or /v1/requests/skill-access) returns it already in status approved:

  • approved_by_id is empty and approval_notes is auto-approved by policy, so an auto-approval is distinguishable from a human one.
  • The API response carries auto_approved: true.
  • The audit log gets request.created followed by request.approved with auto: true and the requester role.
  • Post-approval work runs as for a human approval (for an MCP access request, the install fan-out to the requester’s devices). Activation then proceeds as for any approved request.

If the auto-approval update fails after the request is created, the request stays pending, the failure is logged at error level, and creation does not fail. A pending request from an auto role (that case, or a role switched to auto after the request was created) is decided under the built-in rule, so an org admin can still clear it.

POST /v1/admin/requests/{id}/approve and /deny keep their paths and still accept API keys, but are no longer behind the org-admin gate. Each call is checked against the policy:

Situation Response
Caller’s role is an approver for the requester’s role 200
Caller’s role is an approver in no rule 403 Admin access required
Caller’s role may not approve this requester role 403 naming the requester role
Caller is the requester and allow_self = false 403
Request missing, in another organization, or not pending 404

GET /v1/admin/requests (the full list) remains admin-only. A user who is an approver reaches pending requests through their own views or by ID. The dashboard still shows Approve and Deny only to admins; the policy is exposed for it to use later.

GET /v1/auth/me returns the effective policy as approval_policy, keyed by requester role:

"approval_policy": {
"user": {"mode": "manual", "approvers": ["admin", "user"], "allow_self": false},
"admin": {"mode": "manual", "approvers": ["admin", "super_admin"], "allow_self": true},
"super_admin": {"mode": "auto", "approvers": [], "allow_self": false}
}
  • mode = "auto" removes human review for that role entirely. Use it only for roles you already trust with everything their requests can expose; a user in auto mode can self-provision access to any datasource they can see.
  • Listing user as an approver delegates approval to every member holding that role. Pair it with allow_self = false for genuine peer review.
  • A rule whose only approvers share the requester’s role, with allow_self = false, locks out an organization that has a single member of that role: nobody can approve their requests until a second member exists. Startup logs a warning for each such rule. The config is still accepted, so check the member list before enabling it.
  • A requester whose membership has been removed falls back to the built-in rule, so admins can still clear their pending requests.