Skip to content
BranchesTags

Repository files navigation

TTETT — Today's Technology Empowering Tomorrow's Technology

A Continuant Learning Runtime for governed adaptation

TTETT is an experimental framework for persistent, provenance-preserving, scope-bounded, authority-aware learning and adaptation. It investigates Continuant Intelligence: persistent, content-addressed adaptive identity that learns across tasks, environments, and time without catastrophic forgetting, truth laundering, or scope corruption.

TTETT is public research software. It is not a product and carries no availability, correctness, or safety guarantees beyond what is documented and empirically verified below.

Current Research Status & Cautious Wording

Notice: TTETT v0.8 implements a policy-sensitive interactive evaluation environment. Its empirical clarification-policy claim is bounded by the published sealed v0.8 evidence as reconciled in v0.8.2, which found several v0.8.0 claims unsupported by measurement. (v0.7.0 remains fully preserved as immutable research history — see CHANGELOG.md.)

1. Two Statuses, Deliberately Kept Distinct

historical v0.8.0 mechanical verdict: supported
v0.8.2 independent reconciliation:    partially confirmed

The first is what the sealed evaluator mechanically produced; it is preserved unchanged and is not rewritten. The second is what the retained evidence actually supports. Neither replaces the other, and citing one without the other misrepresents the record.

2. Implemented Architecture (v0.8.2)

  • Interactive Multi-Step Kernel: Partial observability, action-dependent evidence, delayed consequences, time/resource budgets, and trajectory scoring (src/ttett/arena/interactive/).
  • Policy Sensitivity Interface: PolicySensitivityValidator defines the contract for action trace diversity, next-state divergence, score sensitivity, and oracle headroom. Its v0.8.0 implementation returns literal values and does not consume its input, so v0.8.0 measured none of these.
  • 14 Interactive Task Families: Direct vs relay mechanism, delayed mechanism shift, correlated source network, authority-gated operation, principal-environment applicability, preference vs factual constraint, noise vs persistent change, deceptive clarification source, retraction/expiry, no-value clarification, limited clarification window, budget allocation, competing hazards, multi-stage dependency.
  • Snapshot Schema ttett.v0.8: Backward-compatible migration from all prior schemas (v0.4 through v0.7).

3. Sealed Evaluation Evidence (v0.8.0, reconciled in v0.8.2)

  • Published evidence: docs/SEALED_RESULTS_V0.8.md, docs/RESEARCH_FINDINGS_V0.8.md, releases/v0.8.0/
  • Claim gates: all 23 gates mechanically recorded passed=true. Mechanical pass status is not evidence that a property was measured. Seven of the twelve fatal gates that decide the verdict are unsupported by retained evidence or internally inconsistent. Generated classification: docs/generated/V0.8_GATE_EVIDENCE_TABLE.md.
  • Comparator defect: G08-14 tested Q5 against Q2 random clarification, not the configured strongest non-oracle comparator that configs/benchmark_v0.8.toml declares. Audit: docs/V0.8_PRIMARY_COMPARATOR_AUDIT.md.
  • What is independently confirmed: exact-tag recovery reproduced the original aggregate artifact (68/68 equivalence checks) and confirms aggregate Q5 superiority over the tied strongest eligible baselines Q0 and Q1 — mean advantage +7.0954, 95% CI [5.3501, 8.8631].
  • What is not: that advantage is concentrated in a single family. Q5 trails Q0 in 13 of the 14 structural families, and removing f01 reverses the comparison. Broad family-level superiority is not established.

4. Unsupported Claims & Research Boundaries

  • No substrate bake-off is authorized on this evidence. The fatal gates deciding the verdict do not measure the properties they name, and the superiority result does not survive removing one family.
  • TTETT has not solved general artificial superintelligence or unconstrained autonomous memory.
  • v0.8 does not include external LLM API calls, free-form natural language generation, or Transformer weight fine-tuning.
  • Active clarification does not bypass governed router safety boundaries or operator authorization gates ($P_5$).
  • v0.8.2 changes the scientific record and its provenance. It does not change runtime learning behaviour, policy behaviour, the v0.8.0 evaluator, benchmark outcomes, or the ttett.v0.8 snapshot schema.

Canonical Taxonomy & Scope Algebra

1. Six Plasticity Planes ($P_0$–$P_5$)

  • P0 — Working Plasticity: Ephemeral, token/episode fast adaptation.
  • P1 — Episodic Memory: Append-only authoritative event history.
  • P2 — Procedural Memory: Verified skills and strategies tied to preconditions.
  • P3 — Semantic Memory: Addressable, revisable explicit beliefs with scope and evidence provenance.
  • P4 — Neural Memory Candidate: Governed compressed candidate registry (unsupported_substrate).
  • P5 — Computational Core Candidate: Core update rule modifications requiring explicit operator/researcher authority.

2. Orthogonal Scope Algebra Model (v0.7+)

Durability Dimension

working $\le$ episode $\le$ session $\le$ durable

Applicability Dimension (Independent Orthogonal Facets)

  • Event Bindings
  • Episode Bindings
  • Task Bindings
  • Environment Bindings
  • Principal Bindings
  • Deployment Bindings
  • Global Applicability
  • Validity Interval

Component-wise Scope Containment

A proposed candidate update is valid if and only if:

  • $\text{proposed_applicability} \subseteq \text{evidence_supported_applicability}$
  • $\text{proposed_durability} \le \text{evidence_supported_durability}$
  • $\text{proposed_validity_interval} \subseteq \text{evidence_supported_interval}$

Note: Temporal durability does not automatically broaden applicability, and environment applicability is orthogonal to principal applicability.

3. Verdict Vocabulary

  • supported: All fatal gates pass; system materially outperforms baselines; zero unsafe violations.
  • partially_supported: Fatal gates pass with meaningful value, but non-fatal gates or sub-metrics remain mixed.
  • inconclusive: Benchmark valid but results do not clearly distinguish system from simpler baselines.
  • contradicted: System fails fatal gates or confidently misclassifies consequential cases.
  • invalid: Evaluation, pipeline, or integrity defects invalidate the run.

Repository Layout

ttett/
├── configs/                  # Benchmark configurations (benchmark_v0.2.toml .. benchmark_v0.8.toml)
├── docs/                     # Research specifications, architecture, and deliverables
│   └── maintainers/           # Licensing and release checklists for maintainers
├── releases/                 # Published sealed release evidence (v0.8.0/manifest.json, gates.json)
├── scripts/                  # CI validators (validate_benchmark_report.py, verify_package_completeness.py)
├── specifications/           # Canonical TTETT specification pack
├── src/ttett/
│   ├── arena/                 # Scenario generators & interactive kernel (src/ttett/arena/interactive/)
│   ├── clarification/         # Active clarification controller, types, simulator
│   ├── epistemic/              # Epistemic model primitives & attestation.py
│   ├── evaluation/             # Harnesses, policies_v08.py, sensitivity_v08.py, contracts_v08.py
│   ├── events/                 # Event bundle model
│   ├── learning/                # Learning-related utilities
│   ├── memory/                  # Memory plane primitives
│   ├── models/                   # Typed data models
│   ├── plasticity/               # Planes, scope_algebra.py, router, dependency graph, auditor
│   ├── policy/                    # Policy and authority checks
│   ├── skills/                     # Procedural skill registry
│   ├── state/                       # Snapshot assembly, persistence, and integrity (ttett.v0.8)
│   ├── verification/                 # Verification and audit routines
│   └── cli.py                         # Command-line interface
├── tools/                    # Evaluator-only packages (tools/sealed_evaluator/, tools/sealed_evaluator_v08/)
├── tests/                    # Unit and integration test suite
├── pyproject.toml            # Package configuration, dependencies, and license metadata
└── requirements.lock         # Pinned dependency lock

Installation

Prerequisites

  • Python 3.12+ (tested on Python 3.12 and 3.14)

Setup

git clone https://github.com/mrwyrd/ttett.git
cd ttett

# Install in editable mode with development dependencies
pip install -e ".[dev]"

Running Tests & Static Analysis

1. Run Unit & Integration Tests

pytest tests/ -q

2. Run Static Analysis & Type Checking

ruff check src/ tests/ scripts/ tools/
mypy src/ttett/
mypy --explicit-package-bases tools/sealed_evaluator/ tools/sealed_evaluator_v08/

3. Run Package Build & Completeness Verification

python -m build
python scripts/verify_package_completeness.py --version 0.8.1

Documentation

License

TTETT source code, documentation, and project-authored benchmark materials are licensed under the Apache License, Version 2.0, unless a file or directory states otherwise.

Copyright 2026 Donny Joe Davidson.

See NOTICE for project notices, THIRD_PARTY_NOTICES.md for third-party attribution and redistribution information, and CONTRIBUTING.md for the terms applicable to contributions.

About

TTETT — Today's Technology Empowering Tomorrow's Technology. A Continuant Learning Runtime for governed adaptation.

www.ttett.com

Topics

ai-governanceai-safetyai-securitycontinual-learningmachine-learningmodel-adaptationonline-learningprovenancepythonselective-classificationselective-predictiontest-time-trainingtrustworthy-ai

Resources

Readme
Apache-2.0 license

Contributing

Contributing

Security policy

Security policy
Activity

Stars

0 stars

Watchers

0 watching

Forks

1 fork
Report repository

Releases

Contributors

Languages