Every decision is recorded, including the ones that allow. The rest of this page explains how a decision is reached and where to read it afterwards. For exact gate inputs and reason codes, use the complete gate map.
The words
Each word on this page has one meaning. The glossary has the longer entries.- Rung — how much an agent may do without a person: Rung 1 Assistive, 2 Retrieval, 3 Supervised, 4 Bounded. Some stored fields spell the same ladder as an execution authority posture (
advisory,retrieval,approval_required,bounded_autonomous); the rung is the name shown to people. - Agent risk tier —
T1–T4, set at intake from the rung plus vendors, fiduciary flag and financial limit. It decides whether a new agent is approved automatically. It is not the request risk level (R0–R2) on a request. - Door — one of three entry switches: people, API keys, agents.
- Surface — where a request enters: the Console surface or the API surface. Older material says “Door A” and “Door B”.
- Permission — one verb on one resource, such as Manage runs (
runs:manage). The permission reference lists every one. - Role — a fixed, named bundle of permissions. Role grant — one actor holding one role at one scope.
- Scope — where a role grant applies: the platform or one org unit.
- API key scopes — strings on a key or token that narrow its role grants. They grant nothing.
- NHI entitlement — the gate that asks the configured NHI provider whether the agent’s credentials cover the action. Older labels say “NHI scope”.
- Role limits — the environments, tool lists and data access a role carries into a decision (stored as
scopeConstraints).
The four rungs
The rung is stored on the agent asrung. The autonomy hold table compares it with what the action declares about itself — read, run, write, touches sensitive data, sends something out — and the strictest cell wins.
Three rules travel with the table:
- An action that declares nothing is treated as the strictest case: a write that touches sensitive data and sends something out.
- Blocks apply everywhere. Holds apply to ad hoc agent work; inside a published workflow version, the workflow’s own review steps are the holds and the table adds none. A person acting by hand is never held.
- A financial or destructive write counts as a write. There is no stricter row.
autonomyPostureForRung shows the same agent as advisory, so the gates and the views agree.
Stop switches: the kill switch, then the doors
Two kinds of switch can stop work. Inside the engine they run before every other gate. The global kill switch is the engine’s first gate. While it is engaged, every agent dispatch is blocked; workflow and ingress boundaries check it too. The Console’s Emergency stops page holds it, with the doors and budget freezes; one agent or factory is stopped from its own detail page. The doors come next. Each of the three doors (people, API keys and agents) stops new work from one kind of actor until an operator resumes it, and a stopped door refuses withgovernance_door_stopped. The agents door is the engine’s second gate; the people and API keys doors are checked where those requests enter Forge. A door is an availability limit, not a permission rule: resuming it grants nothing.
What each switch stops, who may flip it and where, is in Emergency stops.
The gate sequence
The engine evaluates its gates in a fixed order, the two switches first, and stops at the first block. On the agent dispatch paths, the runner’s prechecks (rows P1–P5) run before the engine, so a missing agent definition or an exhausted token window blocks before the engine evaluates the kill switch. Gates that do not apply to a request are recorded as not applicable; gates after a block are recorded as skipped. The sequence below is generated from the platform’s gate registry, so it cannot drift from it. Rows P1–P5 are the dispatch runner’s prechecks, which run before the engine. Rows 1–16 are the engine sequence,GOVERNANCE_GATE_SEQUENCE.
Starting a workflow run is a separate, single check: the launch permission. Agent checks such as identity, budget and the autonomy hold table run later, when each step is dispatched. The governance pipeline page describes each gate’s inputs.
What a block leaves behind
Every decision writes a record to the governance audit log (governanceAuditLog). An action whose record cannot be written does not proceed. For a block, the record carries:
- The gate that stopped the work, and every other gate’s result: passed, not applicable, or skipped because an earlier gate blocked.
- The reason code — a stable string such as
platform_killed,budget_exceededorautonomy_rung_blocked. The gate registry maps each recorded gate and code to a plain explanation, including codes recorded under an older gate name. - The explanation — a one-line summary on the record. The full decision also carries one reason per evaluated gate and an unblock hint when the platform has enough data to give an honest one.
identity and permission, which are also the names of current agent checks, and scope, safety and policy were each split into more than one check. Such a record is read by its exact name first. When its reason code belongs to that current gate, or the record has no reason code, it is that gate’s record. When its reason code belongs instead to exactly one gate that kept the name, it is that gate’s record. Otherwise the explanation says the record is ambiguous rather than guessing.
A hold caused by a policy records that policy. To read a recorded decision in the Console, open Trust Fabric → Decisions, which explains recorded governance decisions without changing anything. See Decisions.
Where approvals fit
A hold creates an approval. The work waits until a person approves or rejects it, for example in the Console or in Slack, and the first response wins. Recording an approval decision requires theapprovals:approve permission, and a person decides: in the Console, in Slack, by email reply, or through the API with their own Personal key, which decides as that person (Deciding through the API). See Approvals and human-in-the-loop.
Judges
A judge is an agent whose job is to grade a piece of work against a written rubric and return a structured verdict. Judges produce quality and policy signals; they do not authorize anything, and a passing verdict never replaces a Trust Fabric decision. Judges are ordinary agents: they run through the same dispatch, governance gates and telemetry as other agents, appear in the Console agent catalog, and carry the same cost attribution.What judges grade
The platform ships ten judges:
Each rubric ships as a skill: its criteria, weights, scoring
guidance and examples. Updating a rubric is a normal skill change. To add your own judge, see
Author a judge.
The verdict
Every judge returns the same verdict shape, so verdicts can be combined, displayed and compared:- Subject: what was graded (a skill, agent, procedure, workflow run and so on) and a hash of it, used to match later verdicts on the same subject.
- Score and label: an aggregate score from 0 to 100 and a label of
pass,needs_workorfail. - Per-criterion scores, each with a rationale.
- Confidence: the judge’s own estimate from 0 to 1. Only a verdict at or above the judge’s minimum confidence is authoritative.
- Rationale: a written explanation. A very short rationale is rejected as evidence of skipped reasoning.
- Findings (optional): observations worth highlighting. A finding can carry a suggested action that the verdict card shows as a one-click link: open the node editor, edit a skill’s allowed tools, promote agent work to a procedure, or open the agent or procedure editor.
- Provenance: the judge and rubric version, when it ran, what it cost, and what triggered it.
Calibration and override
Judges drift, so operators can check and correct them:- Override. When an operator overrides a verdict, the override is recorded against the subject, and overrides measure how often each judge agrees with people.
- Agreement metrics. A daily rollup computes each judge’s agreement rate over 7, 30 and 90 day windows, shown on the judge’s catalog entry.
- Sampling. A workspace sets how often completed production runs are sent to
judge-workflow-outcome.
Where to look
- Every permission and role, in words: Access in the Console, and the permission reference.
- Operating Trust Fabric day to day: Run Trust Fabric and the Console Trust Fabric pages.
- Error codes: Errors.

