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

# Resolve Access Ambiguity (preview)

> Resolve ambiguous access requests with auditable, multi-model deliberation

**Judges** resolve ambiguous access requests through auditable, multi-model deliberation. A panel of LLM judges weighs evidence and workspace constitution and returns a ruling.

<Warning>
  Judges is in preview. Start in `audit` mode, inspect rulings, and tune the panel and constitution before allowing rulings to affect live requests.
</Warning>

## Overview

Judges sits after deterministic [Rules](/govern/rules). Cedar produces a baseline `permit`, `forbid`, or `no_match`. When the workspace convening trigger says so, the Court reviews the request. Rulings are recorded on the audit trail. Refer to [Judges](/concepts/judges) concept for `judges.*` event types.

The typical workflow is:

1. Keep deterministic requirements in [Rules](/govern/rules).
2. Configure the panel and constitution below.
3. [Roll out Judges](#roll-out-judges) in `audit` mode, review outcomes, then move to `live` when ready.

The sections below explain decision flow, convening triggers, modes, the panel, the constitution, evidence and authority, rulings, fail-closed behavior, and permissions.

### Decision flow

1. Cedar Rules produce a deterministic baseline: `permit`, `forbid`, or `no_match`.
2. The workspace convening trigger decides whether the Court reviews the request.
3. Each enabled judge evaluates the same case context and casts a weighted vote.
4. Dome tallies the votes, applies the Court's configured directional authority, and records the ruling.
5. The workspace mode determines whether the agent receives the deterministic baseline or the Court-adjusted outcome.

A Court failure never grants access. If fewer than two judges return usable votes, the request resolves to `court_unavailable` and is denied.

### Choose when the Court convenes

| Trigger             | Court reviews                                                       |
| ------------------- | ------------------------------------------------------------------- |
| `no_match`          | Requests for which no deterministic Rule decides                    |
| `judge_policy`      | Requests matched by a `judge` Rule                                  |
| `policy_escalation` | Deterministic outcomes opted in through a Rule bundle's Court scope |
| `all`               | Every governed decision                                             |

Use `no_match` to cover gaps in deterministic Rules. Use Judge Rules when the request pattern itself should control contextual review. Use policy escalation when a bundle owner should explicitly authorize review of selected deterministic outcomes.

### Choose how rulings affect requests

| Mode       | Court convenes? | Outcome returned to the agent                                              |
| ---------- | :-------------: | -------------------------------------------------------------------------- |
| `disabled` |        No       | Deterministic Rule outcome                                                 |
| `audit`    |       Yes       | Deterministic outcome. The Court's would-have outcome is recorded          |
| `live`     |       Yes       | Final outcome after the Court ruling and directional authority are applied |

New workspaces start with Judges disabled. `audit` is the recommended rollout path.

### The panel

The panel is the workspace's set of enabled judges and their weights. Dome includes preconfigured judges for common perspectives. Their definitions are immutable, but you can enable, disable, and reweight them. You can also create custom judges with:

* A system prompt
* Personality-axis settings
* A `high`, `medium`, or `low` vote weight

Do not place enforceable requirements only in a judge prompt. Use [Rules](/govern/rules) for deterministic requirements and Guards for content that must be blocked or transformed.

### The constitution

The constitution is a workspace-wide set of clauses included in every deliberation. Use it for contextual guidance such as required evidence, business justification, escalation norms, or regulatory framing.

```text title="Example constitution clause" theme={"system"}
Title: Production data access requires business justification

Treat requests for production data without a cited runbook, ticket, or
on-call responsibility as presumptively forbidden.
```

Constitution clauses guide deliberation. They are not deterministic Rules. Judges can weigh a clause against other evidence.

### Evidence and authority

Every case includes a deliberation context derived from the live deterministic decision:

| Field                  | Meaning                                                                   |
| ---------------------- | ------------------------------------------------------------------------- |
| `convening_reason`     | Which trigger caused review                                               |
| `cedar_baseline`       | `permit`, `forbid`, or `no_match`                                         |
| `determining_fragment` | Rule fragment that produced a deterministic baseline, when present        |
| `premise`              | Plain-language statement of what Cedar decided                            |
| `authority`            | Whether the Court may reduce access, expand access, both, or only observe |

The Court scope on a Rule bundle constrains how far a ruling can move a deterministic baseline:

| Scope    | Effect                                                |
| -------- | ----------------------------------------------------- |
| `none`   | No authority over the bundle's deterministic outcomes |
| `reduce` | May turn a permit into a deny                         |
| `expand` | May turn a deny into a permit                         |
| `both`   | May move the outcome in either direction              |

The final outcome applies this clamp even when the raw vote points outside the Court's authority.

### Rulings and audit

Every convening creates a ruling with:

* The deterministic baseline and final outcome
* Per-judge votes, weights, reasoning, and errors
* Applied constitution clauses
* Confidence, latency, and partial-result state
* Snapshots needed to reproduce the deliberation context

Authorization decisions reviewed by Judges carry `depth: "judges"` and a `ruling_id`. In `audit` mode, the decision remains deterministic but still includes the ruling reference so operators can compare the would-have outcome.

```json title="Decision with a ruling" theme={"system"}
{
  "allowed": true,
  "reason": "permitted by court",
  "depth": "judges",
  "ruling_id": "rul_01HXYZ..."
}
```

### Fail-closed behavior

The Court requires at least two usable votes. Timeouts, provider errors, malformed output, or loss of quorum produce `court_unavailable`. Dome denies the request and records the failure. If a live permit cannot be persisted, Dome also denies because an outcome without a forensic record cannot be enforced safely.

## Requirements

Before you begin, authenticate to Dome and select a workspace.

### Permissions

Judges configuration and rulings use platform permissions. Preconfigured judges remain immutable regardless of `judges.manage`.

| Default roles       | Permission      | Grants                                                                      |
| ------------------- | --------------- | --------------------------------------------------------------------------- |
| All workspace roles | `judges.view`   | View rulings, judges, panel configuration, constitution, and workspace mode |
| `admin`, `operator` | `judges.manage` | Configure mode and panel. Manage custom judges and constitution clauses     |

## Roll out Judges

<Steps>
  <Step title="Keep deterministic requirements in Rules">
    Confirm that mandatory restrictions and common allow paths are covered by Cedar.
  </Step>

  <Step title="Configure the panel and constitution">
    Choose perspectives, weights, and contextual guidance for ambiguous cases.
  </Step>

  <Step title="Enable audit mode">
    Select a narrow convening trigger and collect would-have rulings without changing agent outcomes.
  </Step>

  <Step title="Review outcomes">
    Compare rulings with deterministic decisions, inspect partial cases, and adjust configuration.
  </Step>

  <Step title="Enable live mode">
    Move to live enforcement only after the observed rulings meet your acceptance criteria.
  </Step>
</Steps>