Experimental · V1 under construction

Who authorized
this action?

Authority helps represent, verify and document who was authorized to perform an action, under which rules and from which information.

Months after an AI agent acted, you can ask what authority covered it, and get the same answer every time from the same history.

Not published to npm. Not ready for production. Not independently reviewed or audited.

Decision model

Actual API ↗
Explicit inputsatSequence + authorityTime
  1. AUTHORIZED

    A complete valid chain satisfies the requested capability and constraints.

  2. DENIED

    Available evidence positively contradicts the requested authority.

  3. REQUIRES_APPROVAL

    The chain can proceed only after the required approval is recorded.

  4. UNKNOWN

    The evidence is incomplete, unresolved, or uses an unknown condition.

Event assurance: ASSERTED_UNVERIFIED. Authority does not authenticate journal events. Authority Proof signs attestations, not the underlying events.

Two components, one question

Authority Core decides and records. Authority Proof lets someone else check what was recorded. Each one says what it does not do.

Exists

Authority Core

A deterministic engine. From an event history, an explicit sequence and a trusted instant, it returns one of four outcomes with a reason code: AUTHORIZED, DENIED, REQUIRES_APPROVAL or UNKNOWN.

  • Delegation, sub-delegation, revocation, amount and budget limits, expiry, approvals.
  • Explains a past decision from the history.
  • Issues a single-use ticket for one exact action and redeems it atomically, in memory and on PostgreSQL, with concurrent tests.

It does not authenticate the events it reads, and it never performs the action itself.

Exists · not independently reviewed

Authority Proof

A feature of the engine. An issuance or a redemption becomes a signed attestation (Ed25519 over canonical JSON) that can be checked offline, up to replaying the decision against a journal you supply.

  • Verification levels L0 to L3 and the command authority proof verify.
  • Reproducible test vectors, with interoperability test cases run in the project's own test suite using OpenSSL and Python's standard library. These are our tests, not an independent validation.
  • Every result lists what it does not establish.

It is not an automatic proof that events happened or that an action was executed. The journal's authenticity and completeness are not established.

Exists (V0)

Conformance Lab

Compares another authorization system's answers with the engine's on revocation and over-delegation scenarios. A reproducible check, not a certification.

Planned, not started

SDK

An in-process TypeScript layer to ask before acting. It is not available.

Authorize, redeem a capability, attest

Three steps around an action, in plain words.

  1. AuthorizeA decision is made for one exact action: which tool, which arguments, which amount, which recipient. If it is allowed, it is written down as a ticket with an expiry.
  2. Redeem a capabilityJust before the effect, your system redeems the ticket. It can be consumed only once, and the authority is checked again at that instant.
  3. AttestThe issuance or the redemption can be signed, then verified later by someone else, offline.

Authority never performs the action. Your system does, and only your system can deduplicate or re-check it. Today these steps are transactions and a command-line verifier; the SDK that would chain them for an application is planned and not started.

Try it

Everything below runs from a clone with Node.js 20 or 22. Installing the dependencies (npm ci) needs a network. We then ran the demo and the verification command with no network access at all, on Linux with Node.js 22. No package is published.

git clone https://github.com/theoadam2506-rgb/authority-graph.git
cd authority-graph && npm ci
npm run demo
npm run authority -- proof verify proof/vectors/redemption.json \
  --keys proof/vectors/trusted-keys.json \
  --journal proof/vectors/journals/journal.json

The demo plays a scripted scenario. The last command verifies a published attestation and prints CONSISTENT_L3 and, every time, the list of what that result does not establish. The key in the published vectors is a public test key: it protects nothing.

For whom

Developers

Read the specification and the published test vectors, run the demo, write a scenario. It is a TypeScript repository you clone.

Read the model

Teams and companies

You build agents that delegate. Authority answers the authority question; you supply authenticated identities, an ordered event history and a trusted clock. Exploratory technical support (model review, integration mapping, an adversarial scenario session) is available by written agreement. It is not a certification and it promises no security.

See the services

People affected

When an agent acts for you, you should be able to ask who authorized it, within which limits, and when. Authority produces that record and says plainly what it cannot prove.

Read what is not established

What is not established

The limits matter as much as the features. The main ones:

  • The journal's authenticity and completeness. Verification replays the journal you give it.
  • The independence of an anchor: the verifier chooses it, and the tool does not check where it came from.
  • Identity and time: a key names a key, not a person, and the signing instant is the signer's claim.
  • No timestamping, no non-repudiation, no certification, and no JWS, COSE or WIMSE conformance is claimed.
  • A decision is not permission to execute, and Authority does not run the action.
  • Authority is experimental, not ready for production, and has not been independently reviewed or audited.
Read all the limits

Code, documentation, contact