Who is this agent, and what authority does it actually hold? Forge provides the identity and authority substrate for autonomous systems — cryptographic principals, delegation, quorum, and pre-execution gates that fire before any action proceeds.
An autonomous agent requests permission to execute an action — paying an invoice, modifying a production database, deploying infrastructure. Before the action executes, someone must answer: does this agent have the authority to do this, and has that authority been properly granted, delegated, and not revoked?
The question is not about policy. Policy asks "should this happen given the rules?" Forge asks a prior question: "who is this agent, and what authority does it actually hold?"
Forge is the authority and identity layer of the Ardyn platform. It provides six product-neutral primitives for any entity that can hold authority — human, agent, device, service, or organization.
authorize_transition gate that must pass before an action proceedsForge recognizes seven categories of principal. Each holds and exercises authority differently.
Forge operates through a sequence of authority primitives that flow from identity through to the pre-execution interlock.
A principal is created with a cryptographic identity — typically an Ed25519 key pair. The principal is recorded in Forge with its type, organizational affiliation, and public key fingerprint.
An authority grant is a signed statement: "Principal A grants Principal B the authority to perform action X on resource Y, subject to constraints Z." The grant is itself an AEA (aea_kind: GovernancePrincipalAuthorizationV1), making it verifiable, chainable, and revocable.
A principal holding an authority grant may delegate it to another principal. Delegation carries constraints: the delegate cannot exceed the delegator's authority, and the delegation may be time-limited, scope-limited, or single-use.
For actions requiring multiple principals, a quorum grant defines the set of principals whose agreement is required, the threshold (e.g., 3 of 5), and the action scope. Each principal produces a signed authorization AEA. When the threshold is met, a quorum decision AEA (aea_kind: GovernanceAuthorizationQuorumV1) is issued.
The authorize_transition interlock is the gate that fires before any governed action. It checks:
If all checks pass, the interlock returns ALLOW. The action proceeds to Axiom for policy evaluation and AAECP for execution.
Principal
│
▼
┌─────────────────────────────────────────┐
│ Forge │
│ │
│ Identity ──► Authority Grant ──► │
│ Delegation ──► Quorum ──► │
│ authorize_transition() │
│ │ │
│ ▼ │
│ ALLOW / BLOCK / INSUFFICIENT_AUTHORITY │
└──────────────┬──────────────────────────┘
│
▼
Axiom (policy evaluation)
A financial institution operates an autonomous trading agent. Before the agent can execute a trade above $1 million, the institution requires quorum authorization from two human principals.
AUTONOMOUS_AGENT principal) submits the trade action to Forge.execute_trade authority with a constraint max_amount: 1000000. The requested amount exceeds the grant.HUMAN principals in the trading desk.GovernanceAuthorizationQuorumV1 AEA.authorize_transition interlock checks: identity valid, authority granted, quorum met, action bound to a nonce. Result: ALLOW.If the risk officer had refused: the quorum would not be met, authorize_transition would return INSUFFICIENT_AUTHORITY, and the trade would be blocked before any policy evaluation.
Forge is an authority substrate, not a governance engine. It explicitly does not:
Forge checks whether authority exists. It does not check whether exercising that authority is a good idea under current rules. Policy evaluation is Axiom's domain.
Forge is a gate. AAECP handles the governed execution of actions that pass the gate.
Forge produces governance AEAs (authorizations, revocations, quorum decisions). Execution evidence is produced by the attestation pipeline.
Forge records authority state. ATP aggregates trust posture from evidence.
A Forge authorization grant is a cryptographic primitive within the Ardyn platform. It does not confer legal authority or satisfy regulatory requirements on its own.
Forge is one layer in a stack. It provides authority state; Axiom, AAECP, and ATP consume it.
Sovereign compute platforms provide hardware-rooted device identities. External identity providers (OIDC, SAML) may serve as identity proofing for HUMAN principals.
Axiom reads Forge authority state during policy evaluation. AAECP calls authorize_transition as the first gate in the pre-execution path.
ATP includes authority state in trust profiles. ACTA records authority events as organizational cognition: who was granted what, who delegated to whom.
Forge authority state is independently verifiable — all verification is offline-capable, with AEAs carrying the necessary bytes.
The principal's public key fingerprint is recorded. Any verifier can confirm that authority grants and quorum decisions are signed by the correct key.
Every authority grant references the grant that authorized it. A verifier can walk the chain from the current grant back to the root authority — confirming that no grant exceeds its parent's scope.
A revocation AEA (aea_kind: GovernanceAuthorizationRevocationV1) is cryptographically bound to the grant it revokes. A verifier can confirm that a revoked grant is no longer valid.
For a quorum decision, the verifier can confirm that the required number of principals signed, that each signature is valid, and that the threshold was met.
Forge is implemented in the ardyn-tool-authority crate — Kylewilson04/forge @ c844406. The crate provides 12 modules with 75 tests covering all six authority primitives. The premp-authz binary (AAECP bridge) integrates the Forge interlock into a production authorization pipeline.
principal.rs, 8 tests.delegation.rs, 14 tests.decision.rs, 19 tests.action.rs, 11 tests.authorize_transition() fail-closed gate with 6 guards (agent status, expiry, policy rules, digest match, evidence presence, attestation). Integrated via premp-authz bridge. interlock.rs, 18 tests.Integrated via AAECP bridge: The premp-authz binary calls authorize_transition and produces signed AEA envelopes on ALLOW. The Forge interlock is the first gate in the AAECP pre-execution pipeline — verifying identity, authority grants, action binding, quorum, and evidence before any action proceeds.