adaad 9.78.0

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

⚡ Quickstart  ·  📜 Constitution  ·  🗺 Roadmap  ·  📖 Thesis  ·  🕵️ DORK  ·  🏛 Trust Center  ·  ✅ Verifiable Claims  ·  📋 Changelog

     

The only AI system that governs its own evolution — and can prove it.

ADAAD is not a tool you configure and forget. It is a constitutionally governed autonomous engine that proposes, challenges, shadow-executes, and cryptographically seals every change to itself — before a single line of production code moves.

Every mutation flows through a 16-step Constitutional Evolution Loop. Every approval is scored against 241 Hard-class invariants. Every decision is sealed in a hash-chained cryptographic proof DAG. Your GPG key is the only key that unlocks critical changes.

That last part is not configurable.

What is ADAAD?

ADAAD (Autonomous Development & Adaptive Architecture Daemon) is an open-source, constitutionally governed AI evolution engine built by InnovativeAI LLC. It runs three specialist AI agents — Architect, Dream, and Beast — inside a cryptographically enforced governance loop. The system proposes its own improvements, red-teams them adversarially, shadow-executes them against live traffic, and only promotes changes that survive every constitutional gate.

The result: autonomous software evolution that is auditable, reversible, and structurally incapable of self-modification without human ratification of critical changes.

In numbers:

• v9.78.0 · Phase 144 · 50 shipped innovations · 241 Hard-class constitutional invariants
• 16-step Constitutional Evolution Loop (CEL) — deterministic, replayable
• 3 specialist agents: Architect (governance), Dream (creativity), Beast (optimization)
• 1 HUMAN-0 gate — structurally non-delegatable, cryptographically enforced

Why it matters

AI systems that self-modify without constraint are a liability. AI systems that never self-improve are stagnant. ADAAD is the answer to both.

The core insight: autonomous evolution is safe only when every mutation is constitutionally governed, adversarially challenged, and cryptographically evidenced. ADAAD operationalizes that insight end-to-end, in production, with verifiable proof.

This is not a research prototype. It is a running system with 50 shipped innovations, a public ledger, and replay instructions for every claim.

🌍 World's firsts — verified, replayable, publicly auditable

These are shipped milestones with hash-chained ledger entries, not design goals.

#	Claim	Evidence
1	First constitutionally governed autonomous codebase to self-evolve in production	→ Phase 65
2	First 16-gate Constitutional Evolution Loop with cryptographic proof per mutation	→ CEL
3	First non-bypassable GovernanceGate as a constitutional primitive (GOV-SOLE-0)	→ Architecture
4	First adversarial red-team agent structurally incapable of approving its own challenges (AFRT-0)	→ INNOV-08
5	First hash-chained identity self-model consulted before every mutation proposal (MMEM-0)	→ INNOV-10
6	First constitutional jury requiring 2-of-3 multi-agent verdict for high-stakes mutations (CJS-0)	→ INNOV-14
7	First AI system with a meta-governance entropy budget governing its own constitutional change velocity (CEB-0)	→ INNOV-26
8	First autonomous governance kernel extractable as a standalone semver-managed package (adaad-core)	→ Phase 124
8b	First constitutionally governed community amendment pipeline — structurally incapable of autonomous constitutional change (COMMUNITY-HUMAN0-0)	→ Phase 125
9	First governed AI system with SELF-AWARE-0: no mutation may reduce self-monitoring observability	→ INNOV-28
10	First AI to pass its own constitutional self-recognition test before promotion (mirror_test.py)	→ INNOV-30
11	First governed AI codebase designed to run fully locally on a $200 Android phone	→ Android
12	First autonomous system with deterministic audit sandbox for one-command third-party verification	→ INNOV-36
13	First constitutionally governed Red-Team Response Engine with HUMAN-0-gated amendment routing (GRRP)	→ INNOV-37
14	First adversarially-driven constitutional self-amendment engine with cryptographic provenance (ACSA)	→ INNOV-38
15	First governed agent coalition formation system with proportional stake redistribution (ACF)	→ INNOV-39
16	First AI system with a Self-Proposing Innovation Engine: system proposes its own next capabilities, HUMAN-0 ratifies (SPIE)	→ INNOV-35
17	First Retrieval-Augmented Governance Synthesis layer grounding agent responses in constitutional precedent (RAGS)	→ INNOV-50

All claims are independently verifiable. See docs/VERIFIABLE_CLAIMS.md for replay instructions.

The pipeline

┌─────────────────────────────────────────────────────────────────────────┐
│              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]  241-invariant constitutional    [16] Annotated tag + release evidence
       scoring

Every step is deterministic. Every step produces a ledger record. Every ledger record is hash-chained to its predecessor. The entire pipeline can be replayed from any point in history with python -m app.main --replay strict --verbose.

The three agents

Agent	Accent	Role	Disposition
Architect		Structural reasoning, governance compliance, invariant enforcement	Conservative. Blocks anything that compromises constitutional integrity.
Dream		Creativity, mutation ideation, exploration of the possibility space	Bold. Proposes novelty. Checked by every other layer.
Beast		Performance optimization, resource efficiency, benchmark scoring	Relentless. Maximizes fitness within constitutional bounds.

None of the three can approve their own proposals. The AFRT is structurally prohibited from approving challenges it authored — constitutional invariant AFRT-0.

Shipped capabilities — 50 innovations

INNOV-01 through INNOV-20 — Core governance primitives

Innovation	Module	What it does
INNOV-01 · CSAP	constitutional_stress_test.py	Adversarial stress-testing of constitutional invariants under pathological inputs
INNOV-02 · ACSE	self_awareness_invariant.py	System must recognize its own constitution before being permitted to mutate
INNOV-03 · TIFE	temporal_governance.py	Temporal governance: stale mutation proposals auto-expire; no zombie changes
INNOV-04 · SCDD	constitutional_entropy_budget.py	Entropy budget: constitutional change velocity is itself rate-limited
INNOV-05 · AOEP	governance_archaeology.py	Full excavation of mutation lineage on demand
INNOV-06 · CEPD	counterfactual_fitness.py	Cryptographic Evolution Proof DAG: every fitness decision is hash-chained
INNOV-07 · LSME	temporal_regret.py	Live Shadow Mutation Execution: mutations run against live traffic before promotion
INNOV-08 · AFRT	red_team_agent.py	Adversarial red-team agent structurally incapable of self-approval
INNOV-09 · AFIT	aesthetic_fitness.py	Aesthetic fitness: code quality and elegance as measurable, scored dimensions
INNOV-10 · MMEM	morphogenetic_memory.py	Hash-chained identity self-model consulted before every mutation proposal
INNOV-11 · DSTE	dream_state.py	Dream State Engine: structured creative exploration inside constitutional guardrails
INNOV-12 · MGV	mutation_genealogy.py	Full mutation genealogy — every change traces to its ancestor
INNOV-13 · IMT	knowledge_transfer.py	Inter-agent knowledge transfer with cryptographic provenance
INNOV-14 · CEB	constitutional_entropy_budget.py	Constitutional jury: 2-of-3 multi-agent verdict required for high-stakes mutations
INNOV-15 · CTD	constitutional_tension.py	Surfaces invariant conflicts before they collide in production
INNOV-16 · ERS	emergent_roles.py	Agents adapt their function within constitutional bounds as the system matures
INNOV-17 · APM	agent_postmortem.py	Every failed mutation generates a root-cause ledger entry
INNOV-18 · GJR	constitutional_jury.py	Governance jury protocol with quorum enforcement
INNOV-19 · RST	reputation_staking.py	Agents stake credibility on proposals; losses are permanent and ledger-recorded
INNOV-20 · BRM	blast_radius_model.py	Blast radius modelling: mutation impact surface quantified before approval

INNOV-21 through INNOV-40 — Advanced autonomy and federation

Innovation	Module	What it does
INNOV-21 · GBP	governance_bankruptcy.py	Graceful degradation when invariant pressure reaches critical threshold
INNOV-22 · MCF	mutation_conflict_framework.py	Resolves competing simultaneous mutation proposals
INNOV-23 · CES	constitutional_epoch_sentinel.py	Detects constitutional drift across long time horizons
INNOV-24 · SVP	semantic_version_enforcer.py	Version increments are constitutionally mandated and enforced
INNOV-25 · HAF	hardware_adaptive_fitness.py	Fitness scoring adjusts to available compute
INNOV-26 · GDA	graduated_invariants.py	Invariant weight scales with mutation risk tier
INNOV-27 · RCI	regulatory_compliance.py	Maps constitutional invariants to external regulatory standards
INNOV-28 · IPV	intent_preservation.py	Confirms mutations honour original design intent
INNOV-29 · CED	curiosity_engine.py	Systematic exploration of underexplored capability space
INNOV-30 · MIRROR	mirror_test.py	System must recognize its own constitutional signature before promotion
INNOV-31 · IDE	invariant_discovery.py	System identifies new invariants from operational patterns
INNOV-32 · CRTV	constitutional_rollback.py	Any state can be restored from the cryptographic proof DAG
INNOV-33 · KBEP	knowledge_bundle_exchange.py	Structured inter-agent knowledge packages with provenance
INNOV-34 · FGCON	federation_governance_consensus.py	Multi-instance quorum for distributed deployments
INNOV-35 · SPIE	self_proposing_innovation_engine.py	System proposes its own next capabilities; HUMAN-0 ratifies
INNOV-36 · BIRC	break_it_challenge.py	Structured external red-team with governed response pipeline
INNOV-37 · GRRP	red_team_response.py	Governed Red-Team Response Protocol with HUMAN-0-gated constitutional amendment
INNOV-38 · ACSA	self_amendment_engine.py	Adversarial Constitutional Self-Amendment engine with cryptographic provenance
INNOV-39 · ACF	coalition_formation.py	Agent coalition formation with proportional stake redistribution
INNOV-40 · CELT	agent_learning_transfer.py	Governance insights propagate across the agent coalition

INNOV-41 through INNOV-50 — DORK Intelligence Trilogy

Innovation	Module	What it does
INNOV-41 · DORK-FLEET	dork_living_fleet.py	Persistent DORK agent pool with constitutional lifecycle management
INNOV-42 · DFSB	dork_fleet_server_bridge.py	Real-time DORK agent state exposed to the operator dashboard
INNOV-43 · CVR	constitution_version_ledger.py	Immutable versioned record of every constitutional amendment
INNOV-47 · LKSE	sync_dork_corpus.py	DORK corpus stays current with the full governance history
INNOV-48 · CSS	embedder.py	Vector-space semantic search over the entire constitutional corpus
INNOV-49 · CMU	model_validator.py	Governed LLM backend rotation with constitutional benchmark gate
INNOV-50 · RAGS	grounded_responder.py	DORK responses grounded in retrieved constitutional precedent

Architecture

adaad/
├── adaad/core/              # Governance-critical primitives (adaad-core package)
├── runtime/evolution/       # 16-step CEL implementation
├── security/ledger/         # Tamper-evident hash-chained evolution ledger
├── app/main.py              # Full autonomous loop orchestrator
├── ui/dork.html             # DORK governance intelligence interface
├── server.py                # API server  (POST /api/dork/stream)
├── scripts/adaad            # POSIX CLI shim
├── ops/nginx/               # Subdomain configuration (adaad.pro)
├── artifacts/governance/    # Per-phase ILA and GPG attestation artifacts
└── docs/                    # Full documentation corpus

Layer	Module	Responsibility
Interface	adaad.__main__.py	Command routing, argument parsing, sandbox enforcement
Interface	ui/dork.html	DORK governance intelligence dashboard
Runtime	app/main.py	Full autonomous loop orchestrator
Core	adaad/core/	Governance-critical primitives — the adaad-core package
Evolution	runtime/evolution/	16-step CEL implementation
Ledger	security/ledger/	Tamper-evident hash-chained records
Governance	docs/CONSTITUTION.md	The constitutional document — 241 Hard-class invariants

DORK — Governance Intelligence Layer

DORK (Developer Operator Runtime Kernel) is the institutional intelligence of ADAAD. It is not a chatbot. It is the governance brain that operators use to query, audit, and interrogate the system's entire constitutional history in natural language.

DORK grounds every response in retrieved constitutional precedent via INNOV-50 · RAGS. Ask it why a mutation was blocked two months ago. Ask it which invariants are under the most pressure. Ask it to explain a governance decision in plain English. It answers with citations from the ledger.

Interface: ui/dork.html — available at aponi.adaad.pro or locally via python server.py
Default model: claude-sonnet-4-6
Streaming endpoint: POST /api/dork/stream

See DORK.md for full documentation.

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. Re-run it any time.

What success looks like:

  ✔ 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.

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 (INNOV-43 · CVR). Every constitutional amendment is itself governed by the CEL.

Structural invariants that cannot be bypassed:

Invariant	What it prevents
GOV-SOLE-0	Bypassing the GovernanceGate
AFRT-0	The red-team agent approving its own challenges
COMMUNITY-HUMAN0-0	Autonomous constitutional amendment without HUMAN-0 sign-off
SELF-AWARE-0	Mutations that reduce the system's own observability
DAS-DOCKER-0	Unpinned Docker image tags in production
SPIE-HUMAN0-0	Innovation proposals auto-approved without HUMAN-0 ratification

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

Verifiable claims

Every claim in this README has a ledger entry. Every ledger entry is hash-chained. Full verification corpus: docs/VERIFIABLE_CLAIMS.md.

To run the deterministic audit sandbox yourself:

docker compose up das-demo

One command. No configuration. No trust required.

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, and Retrieval-Augmented Governance Synthesis — are novel, patent-pending inventions of InnovativeAI LLC.

The codebase is open source (Apache 2.0). The underlying governance architecture constitutes proprietary IP. See BRAND_LICENSE.md and TRADEMARKS.md.

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
LinkedIn	linkedin.com/in/innovative-ai-a472513b5
Telegram	t.me/InnovativeAI_adaad

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 established in Phase 125. See CONSTITUTION_PROPOSALS.md.

Built by InnovativeAI LLC · Apache 2.0 · adaad.pro

The global standard for trustable autonomous AI. Governed, proven, running.