---
url: /handbook/governance/the-key-join.md
description: >-
  How DutyGraph joins Task Cards, the owner's holdings, the System Catalog and
  the rule packs into an agent's proposed scopes, what the evaluator checks
  today, and the gap that remains.
---

# The key join

DutyGraph proposes an agent's scopes from one join of four inputs. This page says which parts of that join the code checks today, and which part is still the target.

> **Target:** Task Card × owner's holdings × System Catalog × rule packs = what an agent may hold, and why.

::: warning
**The join is Partial today.** The evaluator checks that each requested scope is catalogued, held by the owner and allowed by the rules. It does **not** yet check that the selected Task Cards need each scope. Rule CEIL-02 describes that check. It is in the default rule pack, but the evaluator does not apply it.
:::

```mermaid
flowchart LR
    RQ["Requested scopes<br/>default: the Task Cards' scope list"] --> E{"Evaluator<br/>code, no AI"}
    TC["Task Card ids<br/>must exist"] --> E
    H["Owner's holdings<br/>access export"] -->|"CEIL-01 ceiling"| E
    SC["System Catalog<br/>scope must be listed"] --> E
    RP["Rule packs<br/>agent rules and SoD"] --> E
    TR["Validated task requirements"] -.->|"CEIL-02<br/>Planned, not enforced"| E
    E --> P["Proposal<br/>Inherited, Auto-trimmed<br/>or Escalated"]
    P --> AC["Approval chain<br/>people judge need"]
    AC --> L["Ledger<br/>hash-linked record"]
```

## What each input answers

| Input | Question it answers | Source today |
| --- | --- | --- |
| [Task Card](../discovery/task-cards.md) | Which recorded work is this request for? | The Company Repo. Today the evaluator checks only that the Task Card id exists. |
| [Holdings](holdings.md) | What access does the owner hold now? | An uploaded access-export CSV. Live directory and identity governance (IGA) connectors are **Planned**. |
| [System Catalog](system-catalog.md) | Which scopes exist, in the `system/action:object` grammar? | Built from the systems the Task Cards name, or loaded as a file. Default scopes are coarse. |
| [Rule packs](rule-packs-and-sod.md) | Which scopes does the company forbid an agent, and which conflicts need a human? | Default packs, or the company's own packs loaded as files. |

## What the evaluator checks today

The evaluator is code. It runs the same way for the app and for an AI chat over MCP. These checks are **Built**:

| # | Check | Result when it fails |
| --- | --- | --- |
| 1 | The rule pack contains CEIL-01. | The evaluation does not run. |
| 2 | Every selected Task Card id exists in the governance registry. | The request is refused. Only existence is checked. |
| 3 | Each requested scope is well formed and listed in the System Catalog. | The request is refused. |
| 4 | **CEIL-01:** the owner holds the scope in the current access export. | The scope is **Auto-trimmed**. No exception applies. |
| 5 | **Agent rules (AGT-…):** no rule forbids the scope. | The rule removes the scope, or escalates it for a human decision. |
| 6 | **SoD:** separation of duties (SoD) is checked for the owner alone, the proposed agent alone, and the owner plus all their active agents plus the proposed agent. | An open conflict on the agent's own scopes is **Escalated**. A person's mitigation does not transfer to the agent. |

Two more checks run later. Each approving decision and the issue step recheck CEIL-01 and the forbidding rules against the current export. If the access export or the rule pins change while a request waits, the next decision is refused as stale until the reviewer reloads.

### Where the requested scopes come from

In the app, a requester picks Task Cards. If they name no scopes, DutyGraph starts from the scopes recorded for those Task Cards. A requester, or their AI chat, can also name scopes directly. The evaluator does not compare named scopes with the Task Cards. Any catalogued scope the owner holds can pass the join, subject to the rules and SoD.

## What CEIL-02 is meant to enforce

The default rule pack defines CEIL-02:

> "An agent's scopes never exceed what its Task Cards need. Owner access alone does not establish work need."

When it is enforced, a scope will need two things: the owner holds it (CEIL-01), **and** a validated requirement of the selected Task Cards supports it (CEIL-02). Today only the first is computed.

## The current gap

* **No intersection.** The evaluator never intersects the requested scopes with the scopes the Task Cards need.
* **Task requirements are coarse.** A Task Card's needed scopes are the scope lines it lists. If it lists none, DutyGraph treats **every catalog scope of the systems it names** as needed.
* **The default catalog is coarse too.** A system named in a Task Card with no listed scope lines gets two generic scopes: `<system>/read:records` and `<system>/update:records`.
* **The ceiling is not a justification.** An owner may hold privileged access their task never uses. Staying inside the owner's holdings does not make a scope necessary or appropriate.

So today the approval chain is where necessity is judged. The manager confirms the work. The role owner and Internal Controls judge whether each scope fits it. DutyGraph records those human judgments. It does not compute proof of necessity.

## The state of each scope

| State | Meaning today |
| --- | --- |
| **Inherited** | The scope is catalogued, the owner holds it, and no rule removes or escalates it. It does **not** yet mean a Task Card proves the scope is needed. |
| **Auto-trimmed** | The owner does not hold the scope, or a rule removes it. The requester cannot add it back. |
| **Escalated** | A rule or an SoD conflict needs a human decision, for example a mitigating control that covers agents. |

## What the join never allows

1. **A human-delegated agent never exceeds its owner's holdings.** CEIL-01 removes the rest, and no exception overrides it. This is a ceiling, not proof that a scope is safe or needed.
2. **A person's clean SoD record does not clear the agent.** SoD runs on the agent alone and on the owner plus all their agents. A person's mitigation does not cover an agent they build.

## The target model

::: info
**Planned.** This model is written down, not built.
:::

```mermaid
flowchart LR
    TC["Task Card<br/>unit of business work"] --> ST["Steps"]
    ST --> BC["Business capability<br/>what the work must do"]
    BC --> EN["Technical entitlement<br/>a permission in a system"]
    AO["Application owner<br/>validates the mapping"] -.-> EN
    EN --> G["Agent Grant<br/>authority for one agent,<br/>under conditions"]
    H["Owner's holdings"] -.->|"ceiling"| G
    R["Rules and SoD"] -.->|"constraints"| G
```

* Each Task Card step names the **business capabilities** it needs, for example "place a hold on a supplier invoice".
* Each capability maps to **technical entitlements** in a system. An authorized application owner validates the mapping.
* Each mapping records its source, evidence, version, validator, confirmation state and effective period.
* The evaluator allows a scope only when a confirmed, validated requirement supports it, the owner holds it, and every rule and SoD check passes.
* **Missing evidence fails closed.** A scope with no validated requirement is not proposed.
* A requester's ability to ask for a scope never overrides business necessity.

The target reuses Task Card records, governance packs and the evaluator. It does not need a separate authorization database.

## Why the join matters

Identity tools record **what a person holds**. Runtime tools record **what an agent did**. Few tools record **why the agent needed it**. DutyGraph aims to make the Task Card that record.

Today the Task Card ties each request to named, recorded work, and people in the approval chain judge whether each scope fits it. Evidence-backed proof of the minimum access a task needs is the target, not the current state. See [Approval, provisioning and revalidation](approval-provisioning-and-revalidation.md) for what happens after a decision.

::: info
**Status.** **Built**: the evaluator checks in the table above, CEIL-01, agent rules, the three SoD checks, rechecks at each decision and at issue, the approval chain and the ledger. **Partial**: task-based justification. Task Card ids must exist and default requested scopes come from the Task Cards, but no CEIL-02 intersection runs. **Simulated**: holdings and identity data in the sample companies. **Planned**: CEIL-02 enforcement, step-level business capabilities, application-owner-validated entitlement mappings, fail-closed evidence checks and live identity connectors.
:::
