Six conceptual layers — AEA → ATP → Forge → Axiom → AAECP → ACTA — form a closed governance loop. Every autonomous action produces verifiable evidence, builds trust, enforces authority, evaluates policy, governs execution, and feeds organizational learning.
The Ardyn Evidence Artifact is the atomic unit of verifiable truth. Every governed action produces a signed, self-contained AEA — independently verifiable by any third party, offline, with no trust in Ardyn required.
Each AEA carries every byte needed for independent offline re-derivation — Ed25519 signature, policy hash, matched rule, agent identity, tool, and timestamp. No external fetches. No whispered trust.
AEAs are produced by Ardyn Core's governance pipeline (issuance) and independently verified by the Verify Service. The same verifier binary can run offline on any machine.
The Ardyn Trust Profile aggregates verified AEAs into a durable, evidence-backed trust posture. Not a score, not a rating — structured, machine-readable, policy-consumable evidence of an agent's behavior over time.
Each ATP is built exclusively from signed AEAs. No subjective ratings. No reputation black boxes. Every claim in the profile traces back to a verifiable artifact.
ATPs are materialized by the Trust Service, which continuously aggregates new AEAs. Policy rules in Axiom consume ATPs as structured input — higher trust postures can unlock broader permissions automatically.
Forge is the authority and identity layer. It answers who holds authority, what they may do, and how that authority was granted — through cryptographic principals, delegation chains, quorum rules, and pre-execution interlocks.
Every entity — human, agent, device, service — has a cryptographic identity. No shared credentials. No impersonation.
Explicit, signed grants define what each principal may do. Scoped by tool, action, and context.
Authority can be delegated with constraints. Sensitive actions can require multi-party quorum approval.
Before any action executes, Forge verifies: Is this principal authorized? Is this grant valid? Are all interlocks satisfied?
Every action is bound to a unique nonce and sequence. Replayed or duplicated requests are rejected.
Implemented by the Agent Registry and Tool Authority services — agent onboarding, authority grants, and tool authorization.
Axiom is the governance engine. It evaluates organizational policy rules against identity, trust state (ATP), authority (Forge), risk, and environment — then renders one of four binding dispositions: ALLOW, BLOCK, ESCALATE, or DEFER.
Policies are organized into business, operational, and technical layers — evaluated first-match-wins. Every decision is deterministic and replayable.
The Axiom Service is a standalone governance binary. Core calls Axiom for policy evaluation. Every decision is signed, chain-recorded, and produces an AEA — independently replayable and auditable.
The Ardyn Autonomous Execution and Control Protocol governs every autonomous action — pre-execution authorization through Forge authority and Axiom policy, independent post-execution verification through AEA evidence, and autonomous closure with a complete audit trail.
Forge verifies identity and authority. Axiom evaluates policy. Both must pass before execution begins.
The action runs within the authorized scope. Every tool call is intercepted and governed.
Results are verified, AEAs are produced, and the execution is independently auditable.
Execution completes with a full audit trail — what was authorized, what ran, and what resulted.
ACTA (Ardyn Cognitive Trust Architecture) converts operational evidence — AEAs, ATPs, governance decisions, and execution traces — into durable organizational knowledge. Not a dashboard. A cognitive memory that survives personnel turnover and feeds back into better policy.
Raw AEAs and execution traces are converted into structured, queryable, causal knowledge about how autonomous systems behave.
Identify recurring escalation patterns, policy gaps, and trust anomalies across thousands of governed actions.
Organizational learning feeds back into Axiom policy — tighten rules where escalations cluster, relax where trust is proven.
Answer complex questions: "Show me every action where an agent with trust below threshold attempted a financial tool."
Knowledge persists beyond individual personnel. When someone leaves, the organization still knows what its systems did and why.
ACTA completes the loop: AEA → ATP → Forge → Axiom → AAECP → ACTA → back to Axiom with better policy. Continuous tightening.
Each layer feeds the next in a closed governance loop. Evidence builds trust. Trust informs authority. Authority scopes policy. Policy governs execution. Execution evidence feeds cognition. Cognition tightens policy. Every cycle makes the system more governed, more auditable, and more trustworthy.
↻ ACTA feeds back into Axiom — continuous tightening
Risk teams that need evidence-backed controls instead of vendor assertions.
Organizations operating under retention, residency, and audit obligations.
Infrastructure teams that need a trust layer across multiple execution surfaces.
Ardyn pilot deployments validate liability reduction, evidence workflows, and operational assurance within your infrastructure before production commitment.