Skip to content

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 ​

InputQuestion it answersSource today
Task CardWhich recorded work is this request for?The Company Repo. Today the evaluator checks only that the Task Card id exists.
HoldingsWhat access does the owner hold now?An uploaded access-export CSV. Live directory and identity governance (IGA) connectors are Planned.
System CatalogWhich 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 packsWhich 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:

#CheckResult when it fails
1The rule pack contains CEIL-01.The evaluation does not run.
2Every selected Task Card id exists in the governance registry.The request is refused. Only existence is checked.
3Each requested scope is well formed and listed in the System Catalog.The request is refused.
4CEIL-01: the owner holds the scope in the current access export.The scope is Auto-trimmed. No exception applies.
5Agent rules (AGT-…): no rule forbids the scope.The rule removes the scope, or escalates it for a human decision.
6SoD: 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 ​

StateMeaning today
InheritedThe 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-trimmedThe owner does not hold the scope, or a rule removes it. The requester cannot add it back.
EscalatedA 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 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.

Source: gitbook/product/governance/the-key-join.md in the DutyGraph repository.

DutyGraph. Pages label each feature Built, In review or Planned.