> ## Documentation Index
> Fetch the complete documentation index at: https://docs.gloo.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Trust Fabric concepts

> What Trust Fabric decides (allow, block or hold for a person), the four autonomy rungs, the kill switch and doors, the gate sequence, and the judges that grade work.

Trust Fabric is Forge's governance system. Before governed work runs — an agent step, a chat reply, a tool call, a procedure — Trust Fabric decides one of three things:

| Outcome | Stored as | What happens |
| - | - | - |
| **Allow** | `pass` | The work goes ahead. |
| **Block** | `block` | The work stops. The decision names the gate that stopped it and a reason code. |
| **Hold for a person** | `hold` | The work pauses until a person approves or rejects it. |

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](https://docs.gloo.com/forge/concepts/glossary.md) 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](https://docs.gloo.com/forge/reference/permissions) 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`).

Agents do not carry a trust level, and no gate reads one.

## The four rungs

The rung is stored on the agent as `rung`. 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.

| Rung | Read | Run | Write | Sensitive data | Sends out |
| - | - | - | - | - | - |
| 1 Assistive | allow | block | block | hold | block |
| 2 Retrieval | allow | block | block | hold | block |
| 3 Supervised | allow | allow | hold | hold | hold |
| 4 Bounded | allow | allow | allow | hold | hold |

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.

An agent with no stored rung is held at Rung 1 Assistive. The autonomy hold table and the chat response check both fail closed to it, and `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 with `governance_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](https://docs.gloo.com/forge/run/trust-fabric.md#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`.

| # | Gate | Label | What it checks | Reason codes |
| - | - | - | - | - |
| P1 | `registryFreshness` | Agent registry presence | — | `registry_missing` |
| P2 | `ownershipCheck` | Accountable owner is traceable | — | `owner_untraceable` |
| P3 | `definitionIntegrity` | Definition integrity | Blocks dispatch when the authoritative definition hash is missing, active-version resolution fails, or the definition does not match its stored hash. | `definition_tampered`, `si02_no_hash`, `si02_version_resolution_error` |
| P4 | `dispatchAuthority` | Worker authority | — | `worker_authority_unavailable` |
| P5 | `tokenWindow` | Model token limit | — | `rate_limit_exceeded` |
| 1 | `globalKillSwitch` | Global kill switch | An absent singleton passes; engaged blocks. | `platform_killed`, `tool_governance_unavailable` |
| 2 | `doorSwitch` | Agents door off-switch | A missing row or a resumed agents door passes; a stopped agents door blocks new agent work until an operator resumes it. | `governance_door_stopped`, `tool_governance_unavailable` |
| 3 | `agentStatus` | Agent status and owner review | Lifecycle failures block; missing lifecycle status defaults to idle. | `agent_not_found`, `agent_review_missing`, `agent_review_overdue`, `agent_unavailable`, `agent_unowned` |
| 4 | `factoryStatus` | Factory status | Only factory\_dispatch; missing factory document passes. | `factory_archived`, `factory_paused` |
| 5 | `chatResponse` | Chat response eligibility | Only the chat\_response action type; rung/status determine eligibility. | `agent_inactive`, `autonomy_insufficient` |
| 6 | `identity` | Agent identity | Without an NHI provider the gate passes and records verificationBasis "unconfigured"; a configured provider's failed verification blocks. | `nhi_verification_failed`, `nhi_not_configured` |
| 7 | `permission` | Required permission keys | Unresolved principal refuses under enforce; declared keys must be held by every applicable authority layer. | `permission_denied`, `principal_unresolved`, `required_keys_undeclared` |
| 8 | `concurrency` | Agent concurrency | Only step/debug dispatch; the existing gate defaults counters as its context contract specifies. | `agent_busy`, `input_unavailable` |
| 9 | `rateLimit` | Dispatch rate limiter | — | `RATE_LIMITED` |
| 10 | `budgetAgent` | Agent budget | Unconfigured budgets or empty envelopes/path pass. | `budget_vm_reserve_violation`, `budget_exceeded`, `budget_insufficient` |
| 11 | `budgetEnvelopes` | Budget envelopes | Unconfigured budgets or empty envelopes/path pass. | `budget_frozen`, `budget_vm_reserve_violation`, `run_cost_cap_exceeded`, `budget_exceeded` |
| 12 | `budgetHierarchy` | Budget hierarchy | Unconfigured budgets or empty envelopes/path pass. | `budget_hierarchy_closed`, `budget_hierarchy_frozen`, `budget_vm_reserve_violation`, `budget_hierarchy_exceeded` |
| 13 | `autonomyHoldTable` | Autonomy holds | Rung-by-declaration evaluation for agent dispatch. | `autonomy_rung_blocked` |
| 14 | `nhiEntitlement` | Agent entitlement | No NHI provider supplies allowed=true. | `scope_insufficient` |
| 15 | `policyRules` | Dispatch policy evaluation | — | `policy_blocked`, `policy_condition_error`, `policy_advisory_require_approval_not_held` |
| 16 | `approvalRequired` | Dispatch approval requirement | Holds only when a policy/approval requirement matches. | `approval_required`, `approval_pending`, `approval_path_unavailable`, `approval_spent`, `release_unavailable`, `original_actor_unauthorized`, `approval_provenance_unavailable`, `approval_pending`, `approval_provenance_unavailable`, `approval_rejected`, `approval_canceled`, `original_actor_unauthorized`, `approval_pending`, `approval_provenance_unavailable`, `approval_rejected`, `approval_canceled`, `original_actor_unauthorized` |

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](https://docs.gloo.com/forge/architecture/flows/governance-pipeline.md) 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_exceeded` or `autonomy_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.

Older records can name a gate by an earlier name. Most earlier names belong to one current gate. A few were reused: the procedure checks once recorded `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](https://docs.gloo.com/forge/console/trust-fabric/decisions.md).

## 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 the `approvals: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](https://docs.gloo.com/forge/reference/http-api/governance#deciding-through-the-api)). See [Approvals and human-in-the-loop](https://docs.gloo.com/forge/run/approvals-and-hitl.md).

## 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:

| Judge | What it grades | Where it runs |
| - | - | - |
| `judge-skill-quality` | Skills (instructions and allowed tools) | Skill review and the synthesis admission panel |
| `judge-agent-quality` | Agent definitions (prompt, skills and tool sets) | The synthesis admission panel for a synthesized agent |
| `judge-procedure-correctness` | Procedures, after their sandbox tests pass | The Procedure Builder |
| `judge-architect` | Workflow graphs produced by the Architect | Architect turns that materially change the graph |
| `judge-workflow-outcome` | Successfully completed production workflow runs | Run completion, at the workspace's sampling rate (every run when it is 1) |
| `judge-primitive-relevance` | Search candidates against a request | Re-ranking existing primitives before synthesis |
| `judge-synthesis-coherence` | A planned set of two or more primitives | The [Coherence Gate](https://docs.gloo.com/forge/run/synthesis-budgets-and-curator.md#the-coherence-gate), before any Builder runs |
| `judge-primitive-feasibility` | Whether a synthesized primitive's tools, skills and models exist in your organization | The synthesis admission panel |
| `judge-curator-duplicate` | Pairs of primitives suspected of overlap | The [Curator](https://docs.gloo.com/forge/run/synthesis-budgets-and-curator.md#the-curator) |
| `judge-knowledge-conflict` | A proven knowledge case and a pending revision of it | Knowledge revisions |

Each rubric ships as a [skill](https://docs.gloo.com/forge/concepts/tool-registry.md): its criteria, weights, scoring
guidance and examples. Updating a rubric is a normal skill change. To add your own judge, see
[Author a judge](https://docs.gloo.com/forge/build/author-a-judge.md).

### 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_work` or
  `fail`.
* **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`.

Judges move through provisional, approved and deprecated stages. Operate them in Console under
[Platform → Judges](https://docs.gloo.com/forge/console/platform/judges).

## Where to look

* **Every permission and role, in words:** [Access](https://docs.gloo.com/forge/console/trust-fabric/access) in the Console, and the [permission reference](https://docs.gloo.com/forge/reference/permissions).
* **Operating Trust Fabric day to day:** [Run Trust Fabric](https://docs.gloo.com/forge/run/trust-fabric.md) and the [Console Trust Fabric pages](https://docs.gloo.com/forge/console/trust-fabric.md).
* **Error codes:** [Errors](https://docs.gloo.com/forge/reference/errors.md).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.