Docs  /  Tracking the evolution of `_AugmentedIntelligence`

Tracking the evolution of _AugmentedIntelligence

This document is the living map of how the program has grown: version lines on disk, architectural eras, capability themes, and the instruments used to keep history honest.

Companion Role
../CHANGELOG.md Session-level added/changed/fixed
ChatSession-Features.md Features from recent development chats
AugmentedIntelligenceSystems.md Current system map
DiscoveryWordPress.md Epistemic journal of findings
Technical paper / PhD thesis / Discovery paper Formal architecture & research framing

1. How to read this program’s history

_AugmentedIntelligence does not evolve only by semver tags. It evolves as product lines on disk (folder names), command surfaces (what you can type at >>), and institutional layers (Lua sims, profiles, safety gates).

Three parallel clocks:

Version folders     →  v3 → v6 → v10 → v11 → v21…
Capability eras     →  commands → speech → perception → RL/MathNN → bridges → publish/ops
Research documents  →  tech paper, discovery paper, thesis, CHANGELOG

Think of it like Civilization’s eras (see conversation on Information → AI): each era does not erase the last; it stacks new agency on old infrastructure.

2. Version lines observed on disk

Sibling trees under the parent source area (names as found; spelling preserved):

Line Typical emphasis (inferred from name + current v11 docs)
v3.1 – Commands Only Early typed/command-centric console
v6.0 – Speech Recognition – Social STT, social interaction surfaces
v6.0 – Typed Commands / On Parallel speech vs typed product forks
v10.0 – Typed Commands Pre-v11 typed-command consolidation
v11.0 – Typed Commands Current research/ops tree documented here
v21 – Laptop / Less Safe / Safe-On / Template Later packaging forks (laptop, safety posture, templates)

This document’s home tree is v11.0 — Typed Commands (Apache-2.0, Macdaddy4sure.ai / Tyler Crockett, 2025–2026).

v11 is not “the end of the tech tree”; it is the best-documented integration platform where speech, typing, perception, memory, LLM, RL, CAD/DCC, and publish/ops meet in one namespace.

3. Capability eras (architectural evolution)

Era 0 — Command kernel

Idea: One process, one prompt, one dispatcher.

  • Tokenize vector<string> → route handlers
  • Growing SpeechCommands.cpp as central registry
  • Settings, sockets, basic OS integration

Civilization analogy: Ancient → Classical — language of control.

Era 1 — Speech and social I/O

Idea: Voice and presence as first-class input.

  • Speech recognition paths (Whisper / cloud STT)
  • Social and human-facing agents
  • Parallel “typed” vs “speech” product forks (v6 naming)

Analogy: Literacy + roads — more ways to issue orders.

Era 2 — Embodiment and memory

Idea: Desktop as sensor-rich environment.

  • Cameras, screen, audio, accessibility
  • Working / short / long-term memory
  • Early vision and OCR

Analogy: Industrial sensors — the state of the world enters the loop.

Era 3 — Perception Bus + LLM orchestration

Idea: Fuse modalities; route reasoning.

  • PerceptionBus fused world model
  • LLM backends, routing, councils
  • Human Interaction Agent + RSI Agent (Lua autonomy)

Analogy: Information Era — representation infrastructure.

Era 4 — Reinforcement learning + MathNN

Idea: In-process learning without shipping every update to the cloud.

  • MathNN dense nets, layers, device placement
  • RLAgentNet, domain RL (gaming, driving, life, Minecraft, …)
  • Curriculum, checkpoints, MySQL RL tables
  • SimpleML classical sandbox

Analogy: Early AI era — policies that update from experience.

Era 5 — Bridges and dry-run actuation

Idea: Act on games, CAD, DCC — safely by default.

  • BridgeProtocol, plugins, BridgeManager
  • Minecraft (chat listen modes, plugin ops, web dashboard)
  • Creo / Blender / Cinema 4D profiles + CreativeDesk
  • Remote CUDA, TensorRT registry, CUTLASS → cuBLAS TF32 (optional per VS config)
  • Body equilibrium, ethics, AD policy, weather desk

Analogy: Industrial + Information — factories (hosts) with freezes and permits.

Era 6 — Publish, integrate, observe (current v11 track)

Idea: Findings and state leave the binary into the world — under gates.

Theme Modules / docs
Discovery → WordPress DiscoveryJournal, dry-run HTML, draft posts
Integrate hub BrainstormIntegrations (IIS/PHP/graphs/Lua)
Program portal ProgramStatePortal, program_web_portal Graphs
Simple ↔ MathNN SimpleMathNNBridge media/feature fuse + gate
CAD/DCC RL CadDccRL mock MDPs + DQN for Creo/SW/Blender/C4D
Config-aware GPU AI_USE_TF32 via Configuration Manager / EnableTf32
Config store → MySQL ai_settings primary; bootstrap settings.txt; MySQLConfiguration.md
Docs corpus 70+ markdown guides + batch .docx export

Analogy: AI era governance — delegate, publish, measure, freeze.

4. Evolution of the operator surface

v3-ish     type phrases → handlers
v6         type OR speak
v10–v11    typed-command product branding + catalog explosion
v11 late   help topics, doctor/selftest everywhere
           discovery / integrate / simple nn / cad rl / cutlass
           Lua globals on every script + agents

Dispatch pattern matured from “one giant switch” toward:

  1. Early-route modules (discovery, creo, nn, cad rl, …)
  2. Plugin registration (PLUGIN_REGISTER)
  3. Developer extensibility / Augmented Actions catalog
  4. Lua institutional simulations on top of the same gates

5. Evolution of safety

Stage Default posture
Early Operator-trusted local tool
Mid Ethics action classify, emergency shutdown
Late v11 Dry-run on bridges/DCC/discovery/IIS; body freeze; AD allowlists; draft WP; TF32 opt-in

The trajectory is consistent: more agency requires more defaults that refuse to act.

6. Evolution of learning

Rules / scripts
  → Classical SimpleML (NB, k-means, regression)
  → MathNN in-process nets + RLAgentNet
  → Domain RL (games, drive, life, minecraft)
  → CAD/DCC parametric RL (mock-first)
  → Hybrid: simple features gate neural heads (SimpleMathNNBridge)
  → Heavy trains: TF pipeline / remote CUDA / TRT (serve-first honesty)

7. Evolution of output (beyond the console)

cout logs
  → WebServer dashboard / overlays
  → Program state JSON + PHP portal
  → Minecraft PHP live charts
  → Discovery journal → WordPress (gated)
  → Graphs JSON for architecture / discovery / RL
  → Docx export of docs corpus

The program is becoming a lab that leaves artifacts, not only a REPL.

8. Recent session arc (tracked in detail)

High-resolution tracking for the development chats that produced this docs/CHANGELOG wave:

  1. Discovery journal + WordPress every finding
  2. IIS/PHP brainstorm → MVP doctor/deploy/graphs
  3. TF32 GEMM → then optional via VS configs (AI_USE_TF32 / EnableTf32)
  4. PHP graphs catalog + portal Graphs UI
  5. Lua brainstorm hub + harness scripts
  6. CHANGELOG + full docs → docx batch
  7. SimpleML/media ↔ MathNN bridge
  8. CAD/DCC RL (Creo, SW mock, Blender, C4D)

See ChatSession-Features.md and CHANGELOG.md.

9. Instruments for ongoing tracking

9.1 What we already have

Instrument Tracks
CHANGELOG.md Operator-visible deltas
Discovery journal Epistemic findings (seed paper/session + new encounters)
Program portal / history.json Live enablement trends
RL checkpoints / MySQL tables Learning progress
Doctor / selftest commands Health of subsystems
Git (when used) Source truth
This file Narrative eras + version lines

On each meaningful ship:

  1. Append CHANGELOG [Unreleased] bullets (Added/Changed/Security).
  2. If it is a finding, not just a feature:
    discovery encounter title … summary … category platform
  3. Update one line in §10 timeline table below (date + theme).
  4. Keep formal papers for major milestones only.

9.3 Optional automation (future)

simple compute recipe ship_notes
  → diff catalog / doctor report
  → discovery add (dry-run)
  → portal export

10. Timeline table (maintain this)

Period Milestone Notes
Pre-v6 Commands-only trees Console kernel
v6 Speech + social forks Dual product lines
v10 Typed commands consolidation Path to v11
2025–2026 v11.0 Typed Commands Tech paper, thesis ch.18, discovery paper
Mid-2026 Perception, agents, RL substrate System map era
Mid-2026 Bridges: Minecraft, CAD/DCC, remote CUDA Actuation + dry-run
Mid-2026 MathNN/TF32/Tensor configs GPU Configuration Manager
Recent Discovery/WP, integrate, graphs, simple↔nn, CadDccRL Publish + hybrid ML + CAD RL
Recent MySQL profiles + Commands/Features spreadsheet refresh 12 new apply profiles
Next (add rows here)

11. Conceptual stack (what “evolved” means)

┌─────────────────────────────────────────────────────────┐
│  Publish & observe   discovery, WP, portal, graphs      │  Era 6
├─────────────────────────────────────────────────────────┤
│  Host actuation      bridges, CAD/DCC RL, dry-run       │  Era 5
├─────────────────────────────────────────────────────────┤
│  Learn               MathNN, RL domains, SimpleML hybrid│  Era 4
├─────────────────────────────────────────────────────────┤
│  Perceive & reason   bus, LLM route, memory, RSI        │  Era 3
├─────────────────────────────────────────────────────────┤
│  I/O                 speech + typed commands            │  Era 0–1
├─────────────────────────────────────────────────────────┤
│  Kernel              Windows process, settings, sockets │  Era 0
└─────────────────────────────────────────────────────────┘

Nothing in the lower layers is obsolete; higher layers depend on them. That is the real evolution story: composable agency under gates.

12. Honest deferred track (not yet “evolved into”)

From CHANGELOG and design docs — still open:

  • Full Adobe / Office live plugins
  • True CUTLASS device MMA .cu
  • SolidWorks full COM live (mock RL exists)
  • In-process TF C++ train (pipeline/serve-first is the truth)
  • Full IIS ARR + signed PHP webhooks
  • Unrestricted public command API

Tracking evolution includes tracking what we refuse to claim.

13. One-sentence summary

_AugmentedIntelligence evolved from a typed-command console into a gated cognitive-ops platform: perceive, remember, learn, act on hosts, and publish findings — with dry-run, ethics, and configuration-aware GPU paths as first-class citizens.

Maintainers: append §10 on each ship; keep CHANGELOG for detail; use discovery for epistemic claims.

Generated from the project markdown docs on 2026-07-24. This is a static, self-contained site.