Authority Graph
Your organization's delegated authority, modeled as a versioned structure your team reviews and approves, then compiled into policy that stays grounded in the live delegations it came from, not rebuilt, just made machine-readable.
Authority exists in documents. Runtimes need it in structure.
A Delegation of Authority policy is written for humans to read and interpret. It answers "who can approve what" in prose, cross-referenced against an org chart that lives somewhere else, and an approval matrix that lives somewhere else again. None of that is queryable by a system that needs an answer in milliseconds, for an actor (an AI agent) that has no judgment to apply to an ambiguous case.
One graph: principals, delegates, limits, and roles
The Authority Graph can ingest your existing governance documents and organizational data, or be authored directly where no single document captures the structure, and produces a single structure connecting who holds authority, who it's been delegated to, what constraints apply, and where that sits in the org's role hierarchy, referencing the systems that already own each of those facts rather than duplicating them. Each approved version is a versioned snapshot your team reviews and publishes. What Runtime Authority evaluates on every intent is the compiled Runtime Policies derived from that snapshot, and those policies stay grounded in the exact delegation relationship they were compiled from: evaluation checks that the relationship still exists and is active in the current authority context before the policy can grant that authority. Revoking or expiring the underlying delegation stops the derived policy from granting it, without anyone editing the policy by hand, answering "under what conditions" against the "who is allowed to delegate what, to whom" the graph itself established. For the schema-level detail (what a delegation record actually contains), see Authority Graph in the Developers section.
What the graph actually models
Governance ingestion or manual authoring
Existing Delegation of Authority documents, approval matrices, and signing schedules can be read directly, as source documents, not as a template to fill in from scratch. Where AI helps extract structure from them, it proposes candidate principals, relationships, and policy language; it can't grant authority or activate anything on its own, and a human reviewer resolves and approves the exact version before it's compiled. A graph can just as validly be authored manually where no single document captures it.
Delegated authority
Who may act on whose behalf is modeled explicitly rather than as a single flat permission, and the graph can represent delegation extending across more than one relationship. Today, Runtime Authority evaluates and narrows one delegation hop at a time, person to one agent, or person to one adapter, live-rechecked and revocation-aware; narrowing verified across a multi-agent or multi-tool chain is the architecture's next step, not a shipped capability yet.
Role hierarchy
Reporting lines and organizational structure are referenced so authority evaluation reflects how the organization is actually structured, not duplicated into a second, parallel hierarchy the team has to keep in sync by hand.
Approval limits
Monetary thresholds, transaction types, and category-specific limits are captured as constraints on delegation, referencing the limit a system like SAP already enforces rather than restating it as a second source of truth.
Cross-system conditions
A delegation can include a condition that only makes sense across more than one system, for example an actor, a sequence, and a time window, without duplicating any single system's own local permissions.
Machine-readable authority
Each reviewed and approved graph version compiles into deterministic Runtime Policies: the same governance structure, in a form software can actually evaluate. Those policies stay grounded in the exact delegation relationships they were compiled from, and evaluation checks that grounding is still active, not just the graph state at compile time.
Bring your Delegation of Authority document
We'll show you it modeled as a graph, reviewed and compiled into policy Runtime Authority can evaluate against, in the same session.