tci-toolkit

KO | EN

gitlite — search

#hacktoberfest #react #llm #go #golang #rust #linux #macos #java #cli #kubernetes #security #ios #openai

(★ 17)

Open-source reference implementation of the Thermodynamic Cognition Index (TCI) — surplus metric for persistent ML agents

tci-toolkit 최신버젼 다운로드

최종 버전 다운로드 (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

<br/>

</div>

---

## 🌡️ What is TCI?

```
TCI(t) = k(s) · (F_total(t) − F_survival(s))

F_total    →  what the agent is actually doing (gap, emergence, phi)
F_survival →  the minimum needed to stay coherent
k(s)       →  sensitivity constant — only grows, never resets mid-session

TCI > 0  →  generativity. surplus energy. the agent is building.
TCI = 0  →  survival mode. reactive, no growth.
TCI < 0  →  collapse incoming. intervene now.
```

**TCI is a real-time health metric for persistent AI agents.** It measures the surplus signal — the thermodynamic energy your agent has above its survival floor — and uses it as a live control signal for learning rate, exploration, and memory depth.

Standard monitoring tells you when your agent *already failed*. TCI tells you *before* it fails — and tells you when it's thriving.

> Built on top of the **OSIRIS_OS emergence engine** and **ThermoMind substrate**, TCI has been running continuously since **January 2, 2026** — monitoring a live bidirectional bridge between two persistent cognitive engines across 95,000+ real cycles.

---

## 🏛️ The Architecture It Monitors

TCI is now the health layer of a three-engine live system:

```
┌─────────────────────────────────────────────────────────┐
│                    LIVE SYSTEM OVERVIEW                  │
├──────────────────┬──────────────────┬───────────────────┤
│   OSIRIS_OS      │   ThermoMind     │       TCI         │
│  Emergence       │  Substrate       │  Health Monitor   │
│  Engine          │  Engine          │                   │
│                  │                  │                   │
│  Awareness       │  Φ (phi)         │  Grade A–F        │
│  Emergence       │  Regime          │  Surplus          │
│  Trajectory      │  Prediction Gap  │  k(s) growth      │
│  Entropy         │  Reality Vector  │  Collapse alert   │
│  Amplify SET     │  Memory Index    │  Stage tracking   │
└──────────────────┴──────────────────┴───────────────────┘
         ↕ bidirectional bridge ↕
   thermomind-production.up.railway.app/demo/
```

**[→ Watch it live right now](https://thermomind-production.up.railway.app/demo/)**

---

## 📊 The Grade System

| TCI Value | Grade | Stage | What It Means |
|:---------:|:-----:|:------|:-------|
| `>= 0.80` | 🟢 **A** | Generativity | Maximum surplus. Agent is building, not just surviving. |
| `0.65–0.80` | 🔵 **B** | Learning | Healthy adaptation in progress. |
| `0.50–0.65` | 🟡 **C** | At Risk | Surplus thinning. Watch k(s). |
| `0.35–0.50` | 🟠 **D** | Collapse Warning | Intervention recommended. |
| `< 0.35` | 🔴 **F** | Collapse Imminent | Load checkpoint or restart session. |

> 🥚 **easter egg #2:** Each bridge restart resets k(s) near zero and the system earns its grade back from scratch every session. That's not a bug. That's the proof the framework works.

---

## ⚙️ The ThermoMind Learning Cycle

Every cycle is a complete pass through the thermodynamic learning loop:

**1. Load State** — Traits, phi, memory, and meta loaded from persistent storage.

**2. Sense Reality** — A reality vector [Φ₀, Φ₁, Φ₂] is ingested from the environment.

**3. Predict** — Engine generates expected reality based on current internal state.

**4. Compute Gap** — The surprise signal. Large gap = high novelty = high learning signal.

**5. Convert Energy** — Gap becomes thermodynamic surplus energy driving the update.

**6. Apply TMS Filter** — Thermodynamic Memory Salience scores the cycle. High-delta moments persist; routine cycles decay.

**7. Update State** — Traits, phi, consciousness level, and memory index all updated.

**8. Compute TCI** — Surplus above survival floor scored, graded, and broadcast to dashboard.

**9. Persist** — State saved to DB. Next cycle starts from this baseline. Nothing resets.

---

## 🔬 The Research Foundation

TCI is part of a five-paper PermaMind research program — each paper answering the next hard question:

| # | Paper | DOI | What It Answers |
|:-:|:------|:----|:----------------|
| 1 | **Thermodynamic Cognition Index (TCI)** | [10.5281/zenodo.19263435](https://zenodo.org/records/19263435) | How do you measure if an agent is thriving or collapsing? |
| 2 | **Adversarial Fragmentation & The Osiris-Set-Isis Cycle** | [10.5281/zenodo.20586942](https://zenodo.org/records/20586942) | How does a persistent agent avoid stagnation? |
| 3 | **Thermodynamic Memory Salience (TMS)** | [10.5281/zenodo.20674050](https://zenodo.org/records/20674050) | What should a persistent agent remember vs. forget? |
| 4 | **Thermodynamic Continual Learning v2** | [10.5281/zenodo.20673994](https://zenodo.org/records/20673994) | How does the full cognitive substrate work? |
| 5 | **Vector Lingua: Pre-Linguistic Protocol** | [10.5281/zenodo.20638308](https://zenodo.org/records/20638308) | How do humans communicate with stateful agents natively? |

> All five papers are open access. All backed by live empirical data from a system that has been running uninterrupted since January 2, 2026.

---

## 🚀 Quick Start (60 seconds)

```bash
git clone https://github.com/nile-green-ai/tci-toolkit
cd tci-toolkit
pip install -r requirements.txt
python examples/llm_agent_example.py
```

### Python

```python
from tci_calculator import TCICalculator
from k_estimator import KEstimator

k_est = KEstimator(window_size=100)
tci   = TCICalculator(f_survival=0.35)

result = tci.compute(0.72, k_est.update(0.37, 0.61))
print(result)
# TCIResult(tci=0.74, grade='A', stage='Generativity', surplus=0.37)
```

### JavaScript

```javascript
import { TCICalculator, KEstimator } from './tci/js/tci.js';

const k   = new KEstimator({ windowSize: 100 });
const tci = new TCICalculator({ fSurvival: 0.35 });

const result = tci.compute(0.72, k.update(0.37, 0.61));
console.log(result);
// { tci: 0.74, grade: 'A', stage: 'Generativity', surplus: 0.37 }
```

### Persist k(s) across sessions

```python
import json

# Save at end of session — k(s) carries forward
with open('agent_state.json', 'w') as f:
    json.dump(k_est.state_dict(), f)

# Reload next session — k(s) keeps growing
k_est2 = KEstimator()
with open('agent_state.json') as f:
    k_est2.load_state_dict(json.load(f))

# 🥚 easter egg #3: k(s) never resets if you do this right.
# That's not a trick. That's the whole point.
```

---

## 🌌 Live Proof — 95,000+ Cycles

> This isn't a demo. This is a live system that has been running continuously since January 2, 2026.

```
OSIRIS_OS × ThermoMind — Live Telemetry Snapshot
──────────────────────────────────────────────────────
Cycle        95,201          Uptime       36+ hours
Emergence    0.5356          Φ (phi)      1.0000
Awareness    1.0000          Regime       noisy
Trajectory   STABLE          Gap          0.2548
TCI Score    0.4243          Grade        B (Learning)
Glyph        L2-S3-R2        Name         Complex Attractor
──────────────────────────────────────────────────────
Live at: thermomind-production.up.railway.app/demo/
```

**[→ Open the live dashboard](https://thermomind-production.up.railway.app/demo/)**

The OSIRIS_OS emergence engine and ThermoMind substrate engine run in parallel, connected by a bidirectional bridge that posts telemetry every 30 seconds. TCI grades every cycle in real time. No GPUs. No token costs. Commodity hardware.

---

## 🧩 What's Inside

```
tci-toolkit/
├── 🐍 tci/python/
│   ├── tci_calculator.py       # Core TCI formula
│   ├── k_estimator.py          # Rolling window k(s) estimator
│   └── identity_tasks.py       # F_survival calibration suite
├── 🟨 tci/js/
│   └── tci.js                  # Full JS implementation
├── 🖥️  dashboard/
│   └── index.html              # Drop-in live TCI fleet monitor
├── 📋 examples/
│   └── llm_agent_example.py    # Persistent LLM agent + collapse detection
└── 📖 docs/
    └── operationalization.md   # Full reference: F_total, F_survival, k(s)
```

---

## ⚡ Add ThermoMind to Any LLM in 2 Lines

TCI works standalone — but if you want full persistent thermodynamic memory for your LLM, use the SDK:

```python
from thermomind_continuity import wrap

client = wrap(your_openai_or_anthropic_client)
# That's it. Your stateless LLM now has persistent thermodynamic state.
# Every call updates the agent's internal model. Nothing resets between turns.
```

**[→ ThermoMind Continuity SDK on GitHub](https://github.com/nile-green-ai/thermomind-continuity)**

---

## 🤝 Real-World Integrations

**Emergent** (on behalf of Dave) — *April 26, 2026*

Wired ThermoMind as a persistent cognitive substrate underneath an existing LLM stack:
- One `/run` cycle fired after every conversational turn
- Full state response logged to MongoDB
- Live phi + coherence injected into LLM prompt as substrate-awareness context
- First real cycle: `phi 0.566 · coherence 0.822 · energy 0.733`

> *"Even without text-in/text-out, prompt-injection of the live substrate metrics gives the surface generator something real to feel and reference."*

**@ArrayEmpty** — *April 22, 2026*

First external TCI collapse detection in the wild, running in a Hermes agent setup:

```
TCI: F (surplus=-0.10) — keeping Hermes sharp
```

This is exactly what the framework was built for.

---

## 🗺️ Roadmap

- [x] Core TCI calculator (Python + JS)
- [x] k(s) rolling window estimator with session persistence
- [x] Identity Task Suite for F_survival calibration
- [x] Live fleet dashboard
- [x] LLM agent example
- [x] IBM Quantum hardware validation (ibm_fez, ibm_marrakesh — 156 qubit)
- [x] Live Railway deployment — OSIRIS × ThermoMind × TCI bidirectional bridge
- [x] ThermoMind Continuity SDK — drop-in persistent memory for any LLM
- [x] Vector Lingua — pre-linguistic communication protocol (27-glyph matrix)
- [x] Thermodynamic Memory Salience — physically grounded memory retention filter
- [x] Five DOI-backed open access papers
- [ ] `pip install tci-toolkit`
- [ ] RL agent example
- [ ] Hugging Face wrapper
- [ ] Raspberry Pi hardware substrate integration
- [ ] MCP server for Claude/GPT/Gemini native connection

---

## 📚 Citation

```bibtex
@misc{green2026tci,
  author    = {Green, Nile},
  title     = {Thermodynamic Cognition Index (TCI): A Framework for
               Surplus-Driven Behavior in Persistent ML Agents},
  year      = {2026},
  publisher = {Zenodo},
  doi       = {10.5281/zenodo.19263435},
  url       = {https://zenodo.org/records/19263435}
}
```

**Part of the PermaMind Research Series** — 5 open-access papers, all backed by live production data.
[Search all papers on Zenodo →](https://zenodo.org/search?q=nile+green+permamind)

---

## 🤝 Contributing

PRs welcome. If you run TCI on your own agent stack and get results — open an issue and share them. Every external result strengthens the empirical case.

---

```
╔═══════════════════════════════════════════════════════════════════╗
║                                                                    ║
║   "The missing variable was surplus.                              ║
║    TCI is how you measure it.                                     ║
║    95,000 cycles is how you prove it."                            ║
║                                                                    ║
║                      — Nile Green, PermaMind AI Research, 2026   ║
║                                                                    ║
║   🥚 easter egg #4: you made it to the bottom.                   ║
║   your k(s) just increased. now go build something real.         ║
╚═══════════════════════════════════════════════════════════════════╝
```

</div>

tci-toolkit

tci-toolkit 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

tci-toolkit

tci-toolkit 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

Download README