AIAD Compliance

Overview

Autonomous Intelligence Agent Design (AIAD) Compliance is the enforcement backbone of the Prismatic Platform's agent ecosystem. Every agent, command, pipeline, and policy artifact must conform to a rigorous specification format before it can be indexed, deployed, or invoked. With over 400 agents operating across 14 functional domains, compliance is not aspirational guidance -- it is a hard gate that blocks non-conforming components from entering the platform.

The compliance framework addresses a fundamental challenge in large-scale multi-agent systems: how to maintain coherent interoperability, auditable behavior, and verifiable quality when hundreds of autonomous components evolve independently. Without enforceable standards, agent ecosystems degrade into collections of incompatible, untestable, and unauditable tools. AIAD Compliance prevents this by binding every agent to a machine-readable contract that specifies its capabilities, authority boundaries, integration points, and doctrine obligations.

AIAD Compliance is not merely a documentation standard. It is an enforceable contract system that binds agents to behavioral guarantees. An agent that declares specific capabilities in its AIAD specification is tested against those capabilities. An agent that declares NO MERCY compliance has its outputs verified against zero-tolerance quality requirements. This contract-based approach transforms the agent ecosystem from a collection of independent tools into a verifiable, composable, and self-auditing intelligence infrastructure integrated with the Trinity Gate verification pipeline.

Core Architecture

The AIAD Compliance system operates through three interconnected layers: specification validation, runtime enforcement, and continuous auditing. Each layer addresses a different temporal scope of compliance -- definition time, execution time, and ongoing operational time.

Specification Layer

At the specification layer, every agent is defined in a .agent.md file following a strict YAML-frontmatter schema. The schema enforces structural completeness before an agent can be indexed.

Runtime Enforcement Layer

During execution, agents are monitored against their declared capabilities. If an agent declares a P95 latency of 200ms for a given capability, the platform's telemetry system tracks actual performance and flags violations. This moves compliance from a static check to a living contract.

Continuous Audit Layer

The audit layer performs daily and on-demand compliance scans across the entire agent registry. Cross-reference integrity, version compatibility, and doctrine adherence are verified automatically. Results feed into the Quality Gates pipeline and contribute to the platform's overall quality score.

Agent Specification Format

Every AIAD agent definition follows a standardized YAML schema that enables machine parsing, automated validation, and registry indexing.

agent-spec:
  name: "blue-drift-detector"
  version: "2.1.0"
  classification: L2-Operational-Specialist
  domain: epistemic-defense
  authority: blue-commander

capabilities:
  - name: behavioral-drift-detection
    confidence: 0.92
    latency_p95_ms: 200
    test_coverage: 100%
  - name: configuration-drift-detection
    confidence: 0.95
    latency_p95_ms: 150
    test_coverage: 100%

enforcement:
  doctrine: "no-mercy-no-doubts"
  version: "2.0.0"
  compliance: mandatory

integration:
  reports_to: blue-commander
  receives_from: [telemetry-aggregator, config-monitor]
  emits_to: [blue-signal-aggregator, purple-coordinator]

quality_gates:
  - all_tests_pass
  - zero_compilation_warnings
  - dialyzer_clean
  - credo_strict_pass

The specification format is intentionally declarative. Agents declare what they can do and under what constraints, and the platform validates these declarations through automated testing. This inversion of control -- where the platform verifies agent claims rather than trusting self-reporting -- is fundamental to maintaining ecosystem integrity at scale.

Compliance Levels

Not all agents achieve full compliance simultaneously. The platform recognizes three compliance tiers to allow progressive adoption while maintaining minimum quality standards.

The enforcement model ensures zero non-compliant agents reach production. Partial compliance is permitted during development and migration phases but carries scope restrictions -- partially compliant agents cannot participate in cross-domain operations or handle security-sensitive data.

Agent Tier System

The AIAD tier system defines escalating levels of authority, capability scope, and responsibility. Tiers are not arbitrary labels; they determine what an agent can invoke, what data it can access, and what operations it can authorize.

Tier Governance Rules

Tier governance prevents authority bypass and maintains the chain of command.

Agent Registry

The Agent Registry maintains a live index of all AIAD-compliant agents. The registry is rebuilt automatically by the AIAD indexer and serves as the authoritative source for agent discovery, capability lookup, and compliance verification.

Registry Operations

# Rebuild the full agent index
./.aiad/bin/aiad index

# Query agents by domain
./.aiad/bin/aiad list --domain=osint

# Verify single agent compliance
./.aiad/bin/aiad verify .aiad/agents/blue-drift-detector.agent.md

# List agents by tier
./.aiad/bin/aiad agents --tier L3

# Validate all definitions
./.aiad/bin/aiad validate

Platform Integration with Elixir/OTP

AIAD Compliance integrates deeply with the platform's Elixir runtime through a dedicated compliance checking module that validates agent specifications programmatically.

defmodule PrismaticAiad.ComplianceChecker do
  @moduledoc """
  Validates AIAD agent specifications against the standard schema.
  Enforces doctrine compliance, capability declarations, and
  integration contract validity.
  """

  @required_fields [:name, :version, :classification, :domain]
  @required_blocks [:enforcement, :capabilities, :quality_gates]

  @spec validate_agent(map()) :: {:ok, :compliant} | {:error, [violation()]}
  def validate_agent(agent_spec) do
    violations =
      []
      |> check_required_fields(agent_spec)
      |> check_required_blocks(agent_spec)
      |> check_doctrine_compliance(agent_spec)
      |> check_capability_metrics(agent_spec)
      |> check_integration_contracts(agent_spec)
      |> check_tier_authority(agent_spec)

    case violations do
      [] -> {:ok, :compliant}
      violations -> {:error, violations}
    end
  end

  defp check_doctrine_compliance(violations, %{enforcement: enforcement}) do
    case enforcement do
      %{doctrine: "no-mercy-no-doubts", compliance: "mandatory"} ->
        violations

      _ ->
        [{:doctrine, "NM/ND enforcement block missing or invalid"} | violations]
    end
  end

  defp check_capability_metrics(violations, %{capabilities: capabilities}) do
    Enum.reduce(capabilities, violations, fn cap, acc ->
      cond do
        not Map.has_key?(cap, :test_coverage) ->
          [{:capability, "#{cap.name}: missing test_coverage"} | acc]

        not Map.has_key?(cap, :confidence) ->
          [{:capability, "#{cap.name}: missing confidence score"} | acc]

        true ->
          acc
      end
    end)
  end
end

This module is invoked automatically during the AIAD indexing process, during pre-commit hooks, and as part of the CI/CD pipeline. Non-compliant agents are blocked at each stage, ensuring that violations are caught as early as possible in the development lifecycle.

Policy Enforcement Hierarchy

AIAD compliance is enforced through a hierarchy of policies that govern different aspects of agent behavior.

Doctrine Policies

Validation Pipeline

The validation pipeline processes agent specifications through six sequential stages. Failure at any stage blocks progression to subsequent stages.

Agent Definition --> Schema Validation --> Doctrine Check --> Capability Verify --> Integration Test --> Deploy
       |                  |                    |                   |                    |
    .agent.md        YAML schema          NM/ND block        Metrics testable     Contract tests
                     validates             present             against spec         with peers

Automated Compliance Checking

The platform performs continuous compliance verification across multiple frequencies.

Command Registry

Alongside agents, AIAD governs the platform's 210+ commands through the Command Registry. Commands follow the same specification-first, validation-enforced pattern as agents.

command-spec:
  name: "/investigate"
  version: "1.5.0"
  category: intelligence
  authority: L2-Operational
  input:
    - name: target
      type: string
      required: true
    - name: depth
      type: integer
      default: 3
  output:
    format: investigation-report
    schema: investigation-report-v2

enforcement:
  doctrine: "no-mercy-no-doubts"
  compliance: mandatory

Coverage Statistics

Performance and Metrics

The compliance system itself is held to strict performance standards to avoid becoming a bottleneck in the development workflow.

Integration

AIAD Compliance is a foundational capability that connects to virtually every other platform subsystem.

• NO MERCY doctrine enforced on all agents through mandatory enforcement blocks
• NO DOUBTS evidence requirements validated in capability declarations
• Trinity Gate validation required for all epistemic agent outputs
• NABLA Axioms compliance mandatory for epistemic domain agents
• Quality Gates integrated into the validation pipeline
• Telemetry Integration tracks agent operation metrics against declared capabilities
• Autonomous Self-Healing detects and repairs compliance regressions automatically
• Color Teams organized under the AIAD tier structure with full specification coverage
• Real-Time Monitoring powers the compliance dashboard for operational visibility
• AIAD Standard defines the underlying specification format that compliance enforces
• Intelligence Synthesis agents validated for NABLA axiom adherence

Connect & Contribute

Created by Tomáš Korcak (korczis) | Open Source under GHL

• GitHub | GitLab | LinkedIn | Contact
• Developer Portal | Architecture | Meet the Creator