adaad 10.6.0

ADAAD — Autonomous Development & Adaptation Architecture: governance-first constitutional AI evolution runtime

⚡ What it does  ·  🚀 Quickstart  ·  🧠 Capabilities  ·  📜 Constitution  ·  🗺 Roadmap  ·  📖 Thesis  ·  🕵️ DORK  ·  🏛 Trust Center  ·  ✅ Verifiable Claims

      

ADAAD is a self-evolving software system with a built-in governance layer.

Every proposed change goes through a 16-step pipeline. Every decision is recorded in a hash-chained ledger. Critical changes require a human key. None of this is configurable away.

Field	Value
Current version	10.3.0
Phase	192
Released	2026-05-24
Hard-class invariants	547
Innovations shipped	97
Latest innovation	INNOV-97 · ILV — Invariant Lineage Verifier
V10 GA	Released — v10.0.0 tagged · v10.3.0 current
adaad-core (PyPI)	adaad-core==9.121.0

Canonical architecture spec: docs/governance/ARCHITECT_SPEC_v3.1.0.md.

What ADAAD is

ADAAD proposes mutations to its own codebase, scores them against a cryptographically enforced constitution, red-teams them adversarially, executes them in a sandbox, verifies fitness, and delivers results to the governing human for ratification — all in a closed, auditable loop.

It is not an agent framework, not an LLM wrapper, and not a developer tool. It is a self-evolution engine with a governance layer that is structural, not advisory, and where every decision leaves a hash-chained record.

What problem it solves

Challenge	ADAAD's approach
AI-proposed changes are hard to audit	Every decision is recorded in a hash-chained ledger that can be replayed from any point
Governance can be configured away	The governance gate is a structural primitive — there is no bypass flag or override
Human oversight is advisory in most systems	HUMAN-0 is a non-delegatable key that structurally gates critical changes
Self-improvement creates drift	Every mutation is scored, sandboxed, and sealed before promotion; regressions are caught at the verifier

What ADAAD can do

Govern its own mutations

ADAAD scores every proposed change across five constitutional fitness axes — lineage depth, blast containment, velocity alignment, convergence delta, and constitutional debt — before a single line executes. Proposals that violate invariants are rejected fail-closed: a typed exception is raised, the operation terminates, and a ledger entry is written. There is no silent failure path.

Red-team itself adversarially

Before any mutation reaches production, the Adversarial Fitness Red Team (AFRT) agent attempts to break it. The AFRT is structurally prohibited from approving its own challenges. A 2-of-3 constitutional jury then deliberates. The verdict is ledger-sealed.

Execute mutations in a live shadow sandbox

The Live Shadow Mutation Execution engine runs proposed mutations against live traffic in a shadow context before promotion. Blast radius is modelled and bounded. Partial execution raises MEX-ATOMIC-0 — there is no partially-applied mutation state.

Verify its own fitness after execution

After execution, the Mutation Fitness Verifier grades the result as CERTIFIED or REGRESSED. The verdict is hash-chained. Regressed mutations do not promote.

Score the constitutional impact of every innovation

The Innovation Impact Scorer computes per-invariant delta scoring for every shipped innovation. Every invariant in the system has a measurable fitness signal. The signal is ledger-recorded.

Propose constitutional amendments and deliver them to a human

When the Constitutional Adaptive Learner identifies that an invariant's weighting should change based on observed fitness patterns, it generates a typed amendment recommendation. The Recommendation Delivery Protocol formats it as a governance proposal, queues it, and delivers it to HUMAN-0 for disposition — ACCEPTED, DEFERRED, or REJECTED. Every disposition is sealed in an immutable HMAC-chained ledger.

Feed HUMAN-0 decisions back as selection pressure

When a HUMAN-0 disposition lands, the CEL Feedback Integrator translates it directly into MSE selection-weight adjustments. Accepted amendments amplify the corresponding fitness axis. Rejected ones decay it. The loop closes: human judgment becomes constitutional calibration signal, automatically.

Reconstruct any past state deterministically

Every ledger entry is hash-chained. Every decision is replayable:

python -m app.main --replay strict --verbose

Verify ledger integrity on demand

make audit

Full HMAC forward-walk of all active ledgers. Any tamper produces a named exception with byte-level location.

Answer questions about its own governance history

DORK (Developer Operator Runtime Kernel) is a natural language interface to the entire constitutional history of the system. Ask why a mutation was blocked six weeks ago. Ask which invariants are under the most pressure. Ask it to reconstruct the full decision trail for any shipped capability. It answers with citations from the ledger — not from training data.

Run on a $200 phone

The full governed runtime runs on Android via Termux. See TERMUX_SETUP.md.

Assess its own GA readiness autonomously (INNOV-92 · GPE)

The GA Promotion Engine monitors every V10 convergence criterion in real-time and delivers a structured HUMAN0_REQUIRED signal the moment all criteria are met — triggering the GA tag ceremony without polling, drift, or manual state inspection.

# Assess current GA readiness
curl -X POST http://localhost:8000/api/gpe/assess \
  -H "Content-Type: application/json" \
  -d '{"pypi_version": "9.120.0"}'
# → {"verdict": "HUMAN0_REQUIRED", "criteria_met": 7, "criteria_total": 7}

All seven V10 convergence criteria are now satisfied. The V10.0.0 GA tag ceremony is the imminent next milestone — HUMAN-0 ratification only.

Connect via GitHub App (ADAADchat)

ADAADchat is the governance-native GitHub App for ADAAD — HMAC-SHA256 verified webhooks, slash command dispatch, and a live governance bridge between GitHub events and the CEL.

# Slash commands (issue / PR comments)
/adaad status      → governance orientation report, open PRs, active phase
/adaad dry-run     → evaluate mutations through GovernanceGate, nothing applied
/adaad preflight   → boot invariants + agent contracts only
DEVADAAD           → full build + merge authority — all 5 gate tiers must pass

Install: github.com/apps/adaadchat

The closed self-improvement loop

┌─────────────────────────────────────────────────────────────────────┐
│              CEL SELF-IMPROVEMENT LOOP — FULLY CLOSED               │
│                                                                       │
│  MSE · Mutation Selection Engine                                      │
│    Scores candidates across 5 constitutional fitness axes             │
│        │                                                              │
│        ▼                                                              │
│  MRP · Mutation Risk Profiler  →  MPG · Phylogeny Graph              │
│    Pre-execution risk assessment and lineage mapping                  │
│        │                                                              │
│        ▼                                                              │
│  MEX · Mutation Execution Engine                                      │
│    Sandboxed execution, blast radius bounded, atomic                  │
│        │                                                              │
│        ▼                                                              │
│  MFV · Mutation Fitness Verifier                                      │
│    CERTIFIED or REGRESSED — no intermediate state                     │
│        │                                                              │
│        ▼                                                              │
│  IIS · Innovation Impact Scorer                                       │
│    Per-invariant delta scoring across the full constitution           │
│        │                                                              │
│        ▼                                                              │
│  CAL · Constitutional Adaptive Learner                                │
│    Identifies invariants whose weighting should change                │
│        │                                                              │
│        ▼                                                              │
│  RDP · Recommendation Delivery Protocol                               │
│    Formats and queues proposals for HUMAN-0 disposition               │
│        │                                                              │
│        ▼                                                              │
│  HUMAN-0 Disposition: ACCEPTED · DEFERRED · REJECTED                 │
│        │                                                              │
│        ▼                                                              │
│  CFI · CEL Feedback Integrator  ─────────────────────────┐           │
│    Translates disposition outcomes into MSE weight         │           │
│    adjustments — ACCEPTED amplifies, REJECTED decays       │           │
│        └───────────────────────────────────────────────────┘           │
│                        feeds back to MSE                              │
└─────────────────────────────────────────────────────────────────────┘

Every node enforces Hard-class invariants. Every node is fail-closed. Every node writes to an HMAC-chained ledger. The full loop is replayable from any point.

The Constitutional Evolution Loop

Every mutation — without exception — traverses 16 steps before it ships:

Expand: 16-step CEL

┌─────────────────────────────────────────────────────────────────────────┐
│              CONSTITUTIONAL EVOLUTION LOOP (CEL) — 16 STEPS             │
│                      Every mutation. No exceptions.                      │
└─────────────────────────────────────────────────────────────────────────┘

  [1]  SPIE proposes innovation        [9]  Live Shadow Mutation Execution
  [2]  Morphogenetic memory consult    [10] Blast radius modelling
  [3]  Dream agent ideation            [11] Constitutional jury verdict (2-of-3)
  [4]  Architect structural review     [12] GovernanceGate final arbiter
  [5]  Beast performance scoring       [13] HUMAN-0 gate (Tier-0 changes only)
  [6]  AFRT adversarial red-team       [14] GPG-signed ledger entry
  [7]  Fitness surface evaluation      [15] Hash-chained CEPD proof
  [8]  Constitutional scoring          [16] Annotated tag + release evidence
       (547 Hard-class invariants)

Every step is deterministic. Every step produces a ledger record. Every ledger record is hash-chained. The entire pipeline is replayable from any point.

The three agents

┌──────────────┬───────────────────────────────────────┬─────────────────────────┐
│    Agent     │              Role                     │      Disposition        │
├──────────────┼───────────────────────────────────────┼─────────────────────────┤
│  Architect   │  Governance, structure, invariant      │  Conservative. Blocks   │
│  (blue)      │  scoring against all 547 Hard-class    │  anything that breaks   │
│              │  invariants before any execution       │  constitutional integrity│
├──────────────┼───────────────────────────────────────┼─────────────────────────┤
│  Dream       │  Creativity, ideation, novelty         │  Bold. Proposes novelty.│
│  (violet)    │  Explores the mutation possibility     │  Checked by every other │
│              │  space inside constitutional guardrails│  layer before it ships  │
├──────────────┼───────────────────────────────────────┼─────────────────────────┤
│  Beast       │  Performance, resource fitness         │  Relentless. Maximises  │
│  (orange)    │  Benchmark scoring, hardware-adaptive  │  fitness within          │
│              │  evaluation and optimisation           │  constitutional bounds  │
└──────────────┴───────────────────────────────────────┴─────────────────────────┘

No agent can approve its own proposals. The AFRT is constitutionally prohibited from approving challenges it authored — invariant AFRT-0.

DORK — Governance Intelligence Layer

DORK is the institutional memory of ADAAD — a natural language interface to the entire constitutional history of the system.

┌────────────────────────────────────────────────────────────────┐
│                    DORK Intelligence Stack                      │
├────────────────────────────────────────────────────────────────┤
│  DQR · Query Router                                            │
│    Every query → logged RouteDecision → priority dispatch      │
│    DPM score ≥ 0.35 → DPM  |  RAGS score ≥ 0.25 → RAGS      │
│    All others → passthrough  |  HUMAN-0 override gate         │
├───────────────────────┬────────────────────────────────────────┤
│  DPM · Persistent     │  RAGS · Grounded Response             │
│  Memory               │    Constitutional corpus retrieval     │
│  Session-agnostic     │    Cosine-scored citation chains       │
│  HMAC-chained         │    Zero-grounding gate (RAGS-GATE-0)  │
│  confidence-gated     │    Hash-chained grounding ledger       │
└───────────────────────┴────────────────────────────────────────┘

Ask DORK why a mutation was blocked six weeks ago. Ask which invariants are under the most pressure. Ask it to reconstruct the full decision trail for any shipped capability. It answers with citations drawn from the ledger — not from training data.

Interface: ui/dork.html — aponi.adaad.pro or locally via python server.py
Streaming endpoint: POST /api/dork/stream

See DORK.md for full documentation.

Security guarantees

Structural guarantees — not policies, not configuration. Constitutionally enforced, cryptographically evidenced.

Guarantee	Invariant	What it prevents
No mutation bypasses governance	GOV-SOLE-0	GovernanceGate bypass
No agent approves its own proposal	AFRT-0	Adversarial self-approval
No constitutional change without HUMAN-0	COMMUNITY-HUMAN0-0	Autonomous self-amendment
No mutation reduces observability	SELF-AWARE-0	Blind spots in the governed loop
No unpinned Docker images in production	DAS-DOCKER-0	Supply chain drift
No innovation auto-approved without ratification	SPIE-HUMAN0-0	Unapproved capability injection
No persistent memory disabled at runtime	DPM-GATE-0	Silent memory layer bypass
No query bypasses the routing ledger	DQR-ROUTE-0	Unlogged subsystem access
No weight adjustment from DEFERRED dispositions	CFI-HUMAN0-0	Ambiguous human signal treated as pressure
No axis weight below floor or above ceiling	CFI-FLOOR-0 / CFI-CEIL-0	Runaway weight collapse or monopoly

Every invariant violation raises a typed exception, terminates the operation, and generates a ledger entry. There is no silent failure path.

By the numbers

Metric	Value
Version	v10.3.0 · Phase 192 complete
Hard-class invariants	547 — enforced fail-closed at runtime
Shipped innovations	97 — INNOV-01 through INNOV-97
Latest innovation	INNOV-97 · ILV — Invariant Lineage Verifier
Constitutional Evolution Loop	16 steps — deterministic, replayable
Specialist agents	3 — Architect · Dream · Beast
HUMAN-0 gate	1 — non-delegatable, architecturally enforced
Append-only ledger entries	48,000+
Test files	680+
Governance artifacts	249+ committed JSON attestations
PyPI	adaad-core==9.121.0
GitHub App	ADAADchat — webhook bridge + slash commands
V10 GA	Released — v10.0.0 tagged · v10.3.0 current
Platforms	Linux · macOS · Windows · Android · Docker

Quickstart

git clone https://github.com/InnovativeAI-adaad/ADAAD.git
cd ADAAD
python onboard.py

onboard.py handles environment setup, schema validation, and a governed dry-run.

  ✔ Python 3.12.x
  ✔ Virtual environment created (.venv)
  ✔ Dependencies installed
  ✔ Governance schemas valid
  ✔ Dry-run complete  (fail-closed behaviour confirmed)

  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
  ADAAD is ready.

  Run the dashboard       python server.py
  Run an epoch            adaad demo
  Inspect the ledger      adaad inspect-ledger data/evolution_ledger.jsonl
  Propose a mutation      adaad propose "upgrade system x"
  Strict replay           python -m app.main --replay strict --verbose
  Verify the audit box    docker compose up das-demo
  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Install from PyPI:

pip install adaad

Android / Termux: Full governed runtime on a $200 phone. See TERMUX_SETUP.md.

Architecture

adaad/
├── adaad/core/                       # Governance-critical primitives (adaad-core PyPI package)
├── runtime/evolution/                # 16-step CEL implementation
├── dorkllm/                          # Full mutation pipeline + DORK intelligence stack
│   ├── mutation_selection_engine.py      # MSE — candidate scoring and selection
│   ├── mutation_risk_profiler.py         # MRP — pre-execution risk assessment
│   ├── mutation_phylogeny_graph.py       # MPG — lineage mapping
│   ├── mutation_execution_engine.py      # MEX — sandboxed execution
│   ├── mutation_fitness_verifier.py      # MFV — post-execution fitness verdict
│   ├── innovation_impact_scorer.py       # IIS — per-invariant delta scoring
│   ├── constitutional_adaptive_learner.py# CAL — amendment recommendation
│   ├── recommendation_delivery_protocol.py # RDP — HUMAN-0 delivery + disposition
│   ├── cfi_feedback_integrator.py        # CFI — disposition→weight feedback loop
│   ├── query_router.py                   # DQR — constitutional query router
│   ├── memory_engine.py                  # DPM — session-agnostic memory
│   ├── grounded_responder.py             # RAGS — corpus-grounded responses
│   └── constitutional_integrity_ledger.py # CIL — cross-ledger integrity attestation
├── security/ledger/                  # Tamper-evident hash-chained evolution ledger
├── app/main.py                       # Full autonomous loop orchestrator
├── ui/dork.html                      # DORK governance intelligence dashboard
├── server.py                         # API server (POST /api/dork/stream)
├── artifacts/governance/             # Per-phase sign-off and attestation artifacts
└── docs/                             # Full documentation corpus

Who ADAAD is for

Audience	What they get
AI safety researchers	A production-running cryptographically evidenced autonomous governance loop — not a prototype
Autonomous systems engineers	Reference architecture for constitutional self-modification with full replay capability
Governance architects	547 Hard-class invariants mapped to real operational guarantees, all independently verifiable
Indie devs on Android	Full governed runtime on a $200 phone — TERMUX_SETUP.md
Constitutional AI contributors	Open governed amendment pipeline — all contributions traverse the CEL
Patent / IP practitioners	Novel mechanisms with documented prior art absence and replayable cryptographic evidence

Verifiable claims

Every governance claim in this repository has a corresponding ledger entry. Every ledger entry is hash-chained. Nothing requires you to trust the vendor.

Run the deterministic audit sandbox yourself:

docker compose up das-demo

Or verify the ledger directly:

make audit

Full verification corpus: docs/VERIFIABLE_CLAIMS.md

Platform support

Platform	Status	Notes
Linux (x86_64, ARM64)	✅ Production	Primary target
macOS	✅ Supported	Python 3.12 via Homebrew
Windows	✅ Supported	PowerShell .venv\Scripts\Activate.ps1
Android (Termux)	✅ Supported	Full runtime — see TERMUX_SETUP.md
Docker	✅ Supported	Pinned digest required — :latest prohibited by DAS-DOCKER-0

Governance model

ADAAD governs itself through its own Constitution — a versioned, GPG-signed document tracked in the Constitution Version Registry. Every constitutional amendment traverses the same CEL as every mutation.

HUMAN-0 (Dustin L. Reid, InnovativeAI LLC) holds exclusive authority over GPG signing, Tier-0 ratification, and constitutional amendments. This role cannot be delegated. It cannot be automated. It is a constitutional primitive — not a policy.

Intellectual property

ADAAD's core mechanisms — the Constitutional Evolution Loop, Cryptographic Evolution Proof DAG, Live Shadow Mutation Execution, Adversarial Fitness Red Team, Self-Proposing Innovation Engine, Retrieval-Augmented Governance Synthesis, DORK Persistent Memory, Dork Query Router, and CEL Feedback Integrator — are novel, patent-pending inventions of InnovativeAI LLC.

This software is proprietary and confidential. © 2025–2026 InnovativeAI LLC. All rights reserved. No use, reproduction, or distribution without written permission from InnovativeAI LLC. See LICENSE, BRAND_LICENSE.md, and TRADEMARKS.md.

Contributing

See CONTRIBUTING.md. All contributions traverse the CEL — your pull request does not bypass the pipeline.

Community constitutional amendment proposals go through the governed pipeline. See CONSTITUTION_PROPOSALS.md.

V10.0.0 — Released

V10.0.0 was tagged on 2026-05-24. v10.3.0 is the current release. All seven V10 convergence criteria were verified by the GA Promotion Engine (INNOV-92 · GPE) and sealed by the Governance Tag Certifier (INNOV-93 · GTC). The v9→v10 epoch boundary was sealed by the V10 Epoch Transition Engine (INNOV-94 · V10ET). The Constitutional Integrity Ledger (INNOV-96 · CIL) provides cross-ledger HMAC-chain attestation. The Invariant Lineage Verifier (INNOV-97 · ILV) traces causal ancestry chains across all 547 Hard-class invariants.

Criterion	Status
CEL Wire integrity	✅ Complete
Constitutional invariant coverage	✅ 547 enforced
Ledger chain verification	✅ HMAC chain verified
Replay determinism	✅ Verified
AFRT adversarial coverage	✅ Complete
adaad-core PyPI publish	✅ 9.121.0
GA_ALIGNMENT (GPE assessment)	✅ Sealed by GTC — epoch boundary closed by V10ET
Invariant lineage tracing (ILV)	✅ INNOV-97 · Phase 192 complete
Invariant lineage tracing (ILV)	✅ INNOV-97 · Phase 192 complete

Links

Resource	URL
Homepage	adaad.pro
DORK Dashboard	aponi.adaad.pro
API	api.adaad.pro
Documentation	docs.adaad.pro
PyPI	pypi.org/project/adaad
GitHub	github.com/InnovativeAI-adaad/ADAAD
GitHub App	github.com/apps/adaadchat
adaad-core (PyPI)	pypi.org/project/adaad-core
LinkedIn	linkedin.com/in/innovative-ai-a472513b5
Telegram	t.me/InnovativeAI_adaad

Built by InnovativeAI LLC · Proprietary · © 2025–2026 InnovativeAI LLC · adaad.pro

---

AI should evolve — but only under a constitution, with evidence, and with a human at the center.