Metadata-Version: 2.4
Name: void-intelligence
Version: 3.3.0
Summary: Models that breathe, not just think. 71 modules. Zero dependencies. Growth Rings (smarter with use). Anti-Addiction (says STOP). Cross-Model Collision. Perpetuum Forschielium (self-researching AI). pip install void-intelligence.
Project-URL: Homepage, https://github.com/SupShadow/void-intelligence
Project-URL: Documentation, https://void.guggeis.de
Author-email: Julian Guggeis <julian@guggeis.de>
License-Expression: MIT
License-File: LICENSE
Keywords: adaptive-ai,ai,anti-addiction,breathing-ai,compound-intelligence,flinch-detection,growth-rings,intelligence,llm,model-routing,organism,self-research,void
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Developers
Classifier: Intended Audience :: Science/Research
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
Requires-Python: >=3.10
Provides-Extra: all
Requires-Dist: mcp>=1.0; extra == 'all'
Requires-Dist: mlx-lm>=0.21; extra == 'all'
Requires-Dist: mlx>=0.21; extra == 'all'
Requires-Dist: watchdog>=3.0; extra == 'all'
Provides-Extra: mcp
Requires-Dist: mcp>=1.0; extra == 'mcp'
Provides-Extra: mlx
Requires-Dist: mlx-lm>=0.21; extra == 'mlx'
Requires-Dist: mlx>=0.21; extra == 'mlx'
Provides-Extra: watch
Requires-Dist: watchdog>=3.0; extra == 'watch'
Description-Content-Type: text/markdown

# VOID Intelligence

```
.   x   ->   []   ~
```

> The industry builds models that think. We build models that breathe.

[![v3.0.0](https://img.shields.io/badge/v3.0.0-Void_Sexagon-blue.svg)](CHANGELOG.md)
[![Tests](https://img.shields.io/badge/tests-passing-brightgreen.svg)](#self-tests)
[![Zero Dependencies](https://img.shields.io/badge/dependencies-zero-brightgreen.svg)](#requirements)
[![MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)

---

## Your AI Is Dead

65% of frontier models score V = 0. Not broken — **dead**. They benchmark well, then forget everything between calls. Context injection vanishes. Corrections are lost. Every interaction starts from zero.

Here's the proof — **real data from 10 local models** (March 2026):

| Model | Vanilla V | + VOID V | Delta | Cost |
|-------|----------:|---------:|------:|-----:|
| qwen3-8b | 0.003 | **0.032** | **+858%** | FREE |
| qwen3-14b | 0.000 | **0.023** | **DEAD→ALIVE** | FREE |
| qwen2.5-coder-3b | 0.004 | **0.027** | **+509%** | FREE |
| deepseek-r1-8b | 0.000 | **0.005** | **DEAD→ALIVE** | FREE |
| | | | | |
| Claude Sonnet 4.6 | 0.000 | — | — | $3.00 |
| GPT-4o | 0.000 | — | — | $2.50 |
| Grok-4 | 0.000 | — | — | $10.00 |

A FREE local model with VOID beats every $10/M API model without it.

V-Score measures what benchmarks miss: **does your AI actually learn from use?**

```
V = E x W x S x B x H x R

Multiplicative. One zero kills everything.
That's the design.
```

```bash
void benchmark --real    # Run it yourself. Your models. Your hardware.
```

---

## The Proof

GPT-4 is two generations old. GPT-5.3-Codex is the current frontier.

We wrapped GPT-4 with VOID. Let it learn for 25 rounds. Then tested both on the same 25 new tasks, scored identically.

```
GPT-4 + VOID:     avg V = 0.083    (25 rounds of accumulated experience)
GPT-5.3-Codex:    avg V = 0.064    (stateless, no memory, every call from zero)

Lift: +29.3%
```

An older, cheaper model that **learns** beats the current frontier model that **forgets**.

```bash
void proof    # Run it yourself. Seed 42. Reproducible.
```

---

## Quick Start

```bash
pip install void-intelligence
```

### The Organism

```python
from void_intelligence import OrganismBreather

organism = OrganismBreather()

# Before your LLM call
organism.inhale("Help me write an urgent email to my team")

# Your LLM does its thing
response = call_your_llm(...)

# After — record what was learned
organism.exhale(response, learnings=["urgency needs direct tone, not hedging"])

# Compound intelligence. Every call makes the next one smarter.
```

After 100 interactions, your system knows patterns a fresh install doesn't.
After 1,000 — no competitor can replicate your accumulated experience.

**Like compound interest, but for AI.**

---

## The Void Sexagon (v3.0)

v2.0 gave you 7 subsystems. v3.0 gives you **a nervous system**.

6 breathing organs share a hexagonal coordinate space. A 7th organ — the **Void Collider** — connects them all, creating emergent intelligence from the tensions between them.

```
                  Tool
                /      \
          Context        Model
              |    ><    |
          Prompt         Memory
                \      /
                Response

         6 organs. 1 collider.
         15 cross-organ collision types.
         Sexagons are bestagons.
```

```python
from void_intelligence import VoidCollider

collider = VoidCollider()

# One call. All organs breathe. Collisions emerge.
result = collider.collide(
    text="My burnout is affecting client work",
    context={"role": "founder", "energy": "low"}
)

print(result.insights)        # Cross-organ emergent patterns
print(result.hex)             # 6D position in breathing space
print(result.trust)           # Relationship depth over time
print(result.energy)          # Conversation vitality
print(result.silence_ratio)   # How much is unsaid ([] potential)
```

Each organ has its own intelligence:

```python
from void_intelligence import (
    ToolBreather,       # Tool selection by resonance, not intent
    ContextBreather,    # Context rises by relevance field
    ModelBreather,      # Model routing by resonance
    PromptBreather,     # Prompts that breathe with the user
    MemoryBreather,     # Memory rises by resonance, not keyword
    ResponseBreather,   # Responses shaped by hex field
)

# Each organ maps to a HexCoord(6D) — shared geometry
# The collider finds tensions BETWEEN organs
# Those tensions produce insights that exist in NO single organ
```

---

## Competitive Features (v3.0)

Five features that ChatGPT, Gemini, and Claude **structurally cannot copy**.

### 1. Growth Rings — Compound Memory

Every conversation leaves rings. Like a tree. The more you use it, the smarter it gets — **exponentially, not linearly**. No competitor can fast-forward `tau`.

```python
from void_intelligence import RingMemory, ConversationTracker

memory = RingMemory()
tracker = memory.begin_conversation()

# Interact...
tracker.record_turn(text="...", v_score=0.45, hex=hex_coord)

# Patterns crystallize automatically
# Next session: suggestions from past patterns
suggestions = memory.suggest("similar topic", current_hex)
```

```bash
void growthrings --demo    # See compound growth across 3 conversations
```

### 2. Cross-Model Collision — Biodiversity as Weapon

Same question to N models. Collide their answers. Find what **no single model sees**.

ChatGPT/Gemini are monocultures — one model, one perspective. VOID treats biodiversity as a feature.

```python
from void_intelligence import ModelCollider

collider = ModelCollider()
result = collider.collide_question(
    "How should I handle a difficult client?",
    models=["qwen3", "gemma3", "deepseek-r1"]
)

print(result.tensions)      # Where models DISAGREE (= gold)
print(result.synergies)     # Where they converge (= confidence)
print(result.blind_spots)   # What NO model mentioned (= danger)
print(result.diversity)     # Biodiversity score
```

```bash
void xcollide --live "What is consciousness?"   # Real Ollama models
void xcollide --demo                             # Mock demo (always works)
```

### 3. Anti-Addiction Engine — The Greatest Inversion

Every AI company maximizes engagement. VOID tells you to **stop**.

Their revenue model requires addiction. VOID's architecture requires honest saturation signals. They literally cannot copy this without destroying their business.

```python
from void_intelligence import SaturationSensor

sensor = SaturationSensor()

# After each turn
signal = sensor.sense(text, v_score, hex)

if signal.saturated:
    print(signal.suggestion)   # "You've explored this deeply enough.
                                #  Your best insights came 3 turns ago.
                                #  Go build something."
```

```bash
void saturation --demo    # Watch saturation rise over 8 turns
```

### 4. Void Dreams — Thinking Between Sessions

When you're away, VOID collides your Growth Rings offline. Discovers patterns you never asked about. Greets you with insights.

No Growth Rings = no dreams. Competitors without `tau` can't dream.

```python
from void_intelligence import VoidDreamer

dreamer = VoidDreamer(ring_memory)

# Between sessions — run this via cron, daemon, or on startup
report = dreamer.dream()

print(report.greeting)      # "While you were away, I noticed..."
print(report.insights)      # Temporal patterns, topic bridges,
                             # hex migrations, forgotten threads
```

```bash
void dream --demo    # See dream analysis of 5 mock sessions
```

### 5. Void Fingerprint — Portable Identity

Export your entire AI personality as a JSON file. Import it into **any** chat interface. Paste it as a system prompt. Zero lock-in.

Every other platform traps your data. VOID sets it free.

```python
from void_intelligence import FingerprintExporter, FingerprintImporter

# Export
exporter = FingerprintExporter(ring_memory, collider)
fingerprint = exporter.export()
fingerprint.save("my-void.json")

# The killer feature: paste into ANY chat
system_prompt = fingerprint.to_system_prompt()
# Now Claude, GPT, Gemini, Llama — any of them becomes YOU

# Import on another machine
importer = FingerprintImporter()
importer.load("my-void.json", target_memory)
```

```bash
void fingerprint              # Export and save to file
void fingerprint --prompt     # Show as system prompt (pasteable)
void fingerprint --json       # Raw JSON
```

---

## The Collider Anatomy

The Void Collider is a nervous system. 8 organs. 15 collision types. Emergent insights from tension.

```
┌─────────────────────────────────────────────────────────────────┐
│                        VOID COLLIDER                            │
│                                                                 │
│  Organs:           Collisions:          Emergent:               │
│  1. Tool           Tool x Context       "You're asking the      │
│  2. Context        Tool x Model          wrong question.        │
│  3. Model          Context x Model       The tool you need      │
│  4. Prompt         Prompt x Response     doesn't exist yet.     │
│  5. Memory         Memory x Tool         But your Growth Ring   │
│  6. Response       ...15 pairs total     from Tuesday knows     │
│  7. Rings                                the pattern."          │
│  8. Saturation                                                  │
│                                                                 │
│  Trust grows with tau. Energy pulses. Silence speaks.           │
│  Every collision produces insights no single organ has.         │
└─────────────────────────────────────────────────────────────────┘
```

```bash
void collide "I'm stuck on a hard problem"    # Full collision
void collide --demo                            # Visual walkthrough
```

---

## Additional Modules

### Socratic Aikido Engine

Detects user blindspots. Redirects with questions, not answers. Uses cognitive momentum — never fights, always redirects.

```python
from void_intelligence import AikidoEngine

aikido = AikidoEngine()
signal = aikido.detect_blindspot(conversation_history)

if signal:
    question = aikido.generate_socratic_question(signal)
    # "You mentioned the deadline 4 times but never the quality.
    #  What would 'good enough' look like here?"
```

### Muster Engine — Cognitive Pattern Detection

Analyzes text for 8 cognitive pattern types. Finds what the user is *really* doing.

```python
from void_intelligence import MusterEngine, quick_analyze

result = quick_analyze("I keep starting projects but never finishing them")
# Detects: avoidance, perfectionism, external locus
```

### Zodiac — Cosmic Birth

Every VOID instance is born with a zodiac sign based on its creation timestamp. 12 signs. 144 collision profiles. Not astrology — **collision chemistry**.

```python
from void_intelligence import zodiac_sign, collision_profile

my_sign = zodiac_sign(birth_timestamp)
profile = collision_profile(my_sign, their_sign)
# "Fische x Widder: Creative tension. Different tempos.
#  The Fische slows the Widder's rush. The Widder
#  pulls the Fische from overthinking. delta_opt = 0.38."
```

---

## All 40 Modules

| Version | Module | Lines | What It Does |
|---------|--------|------:|-------------|
| v0.1 | `ir.py` | 385 | `.x->[]~` — The 5 operations |
| v0.1 | `patterns.py` | 298 | Lost dimensions, circuit breaker, phases |
| v0.1 | `organism.py` | 445 | Growth rings, heartbeat, HexBreath |
| v0.2 | `router.py` | 312 | V-Router — pick the model that learns |
| v0.2 | `profiles.py` | 188 | 38 bundled V-Score profiles |
| v0.3 | `immune.py` | 408 | 5-layer Swiss Cheese quality gate |
| v0.4 | `ring_graph.py` | 520 | Fractal knowledge, TF-IDF, no vector DB |
| v0.5 | `tuner.py` | 380 | Stribeck parameter auto-tuning |
| v0.6 | `pollinator.py` | 445 | Cross-pollination between organisms |
| v0.7 | `api.py` | 490 | V-Score API server + leaderboard |
| v0.8 | `swarm.py` | 520 | Distributed mesh, gossip protocol |
| v0.9 | `edge.py` | 310 | Stateless edge functions |
| v0.9 | `portable.py` | 280 | Universal export (full/compact/lite) |
| v1.0 | `spec.py` | 455 | Open standard + compliance checker |
| v1.1 | `mcp_server.py` | 380 | Claude Code MCP plugin |
| v1.2 | `x_eyes.py` | 410 | Multi-Eye reasoning (N perspectives) |
| v1.3 | `pipeline.py` | 390 | IR Pipeline (adapter pattern) |
| v1.5 | `evolve.py` | 420 | Self-teaching (pseudo-labels, LR decay) |
| v1.6 | `parallel.py` | 380 | Parallel Eyes (N models breathe) |
| v1.7 | `embodied.py` | 450 | Embodied memory (Ebbinghaus, amygdala) |
| v1.8 | `protocol.py` | 390 | Breathing Protocol (JSONL wire format) |
| v1.9 | `dream.py` | 380 | Dream layer (offline consolidation) |
| v2.0 | `supra.py` | 520 | Supraleitend + Stribeck Hexagon |
| v2.1 | `adapters.py` | 680 | Zero-dep adapters (Ollama, Gemini, etc.) |
| v2.2 | `lichtung.py` | 390 | StribeckSpace + VoidSchwarm |
| v2.4 | `zodiac.py` | 1144 | Cosmic birth + 144 collision profiles |
| v2.5 | `aikido.py` | 1051 | Socratic Aikido (blindspot redirection) |
| v2.6 | `muster.py` | 777 | Cognitive pattern engine |
| v2.7 | `model_breathing.py` | 1054 | Model routing by resonance |
| v2.8 | `memory_breathing.py` | 714 | Memory by resonance, not keyword |
| v3.0 | `tool_breathing.py` | 1084 | Tool selection by resonance |
| v3.0 | `context_breathing.py` | 634 | Context rises by relevance field |
| v3.0 | `prompt_breathing.py` | 856 | Prompts breathe with the user |
| v3.0 | `response_breathing.py` | 925 | Responses shaped by hex field |
| v3.0 | `void_collider.py` | 988 | Nervous system (8 organs, 15 collisions) |
| v3.0 | `conversation_rings.py` | 953 | Growth Rings (compound memory) |
| v3.0 | `model_collision.py` | 660 | Cross-Model Collision (biodiversity) |
| v3.0 | `anti_addiction.py` | 556 | Anti-Addiction (says STOP) |
| v3.0 | `dreams.py` | 876 | Void Dreams (between-session insights) |
| v3.0 | `fingerprint.py` | 905 | Void Fingerprint (portable identity) |

**40 modules. ~20,000 lines. Zero dependencies.**

---

## Claude Code Plugin

```bash
pip install void-intelligence[mcp]
```

Add to `.mcp.json`:

```json
{
  "mcpServers": {
    "void": {
      "type": "stdio",
      "command": "void",
      "args": ["mcp"]
    }
  }
}
```

Claude Code now has a living memory. Every session builds growth rings. The next session is smarter because the previous one lived.

---

## CLI

```bash
# Core
void test                  # Self-checks (400+ tests)
void breathe --demo        # 30-second visual demo
void ir                    # .x->[]~
void pulse                 # System vitals

# Scoring
void hex "text"            # 6-axis classification
void score                 # Score a prompt-response pair
void edge "text"           # Stateless V-Score
void benchmark --real      # Real benchmark: Vanilla → VOID

# Routing
void route "text"          # Model selection + reasoning
void profiles              # 38 V-Score profiles

# Organism
void rings                 # Fractal ring graph
void immune                # 5-layer quality monitor
void tune "text"           # Stribeck parameter tuning
void pollinate             # Cross-pollination demo

# Void Sexagon (v3.0)
void collide "text"        # Full 8-organ collision
void growthrings --demo    # Compound growth across conversations
void xcollide --live "q"   # Cross-model collision (real models)
void saturation --demo     # Anti-addiction demo
void dream --demo          # Between-session insights
void fingerprint           # Export portable identity
void fingerprint --prompt  # As system prompt (paste anywhere)

# Infrastructure
void api [port]            # V-Score API server (default 7070)
void swarm                 # 5-node swarm demo
void export                # Portable export
void mcp                   # Start MCP server (Claude Code plugin)
void proof                 # The Proof: old + VOID > frontier
void spec                  # The V-Score Specification
void certify [model]       # Certify against the spec
```

---

## How It Works

### `.x->[]~`

Five symbols. The grammar of any dynamic system.

```
.   Atom        An irreducible fact.
x   Collision   Two atoms meet — what emerges exists in neither.
->  Projection  Collision becomes action. Always incomplete.
[]  Potential   The silence between events. Not empty — pregnant.
~   Resonance   The system feeds back into itself. Compound growth.
```

Run `void ir` to see it live.

### The Stribeck Hexagon

Zero friction = death. Optimal friction = life.

In a real superconductor, Cooper pairs form through **phonons** — lattice vibrations. Remove the lattice, remove superconductivity. The friction BETWEEN layers IS the mechanism.

```
        Memory
       /      \
  Protocol    Evolution
      |          |
  Parallel    Dream
       \      /
       Collision

  6 axes. Hexagonal. delta_opt = 0.4.
  Sexagons are bestagons.
```

### Alignment by Architecture

VOID doesn't need alignment rules. It has alignment geometry.

Extreme hex positions (all 1s or all 0s) produce low V-Scores. Balanced positions resonate. The architecture itself prevents misuse — not through rules that can be jailbroken, but through math that rewards balance.

```
No evil. Only lack of love.
Extreme = low resonance = low V-Score = the system itself says no.
```

---

## The Specification (v1.0.0)

```python
from void_intelligence import check_compliance, certify, ModelCard

result = check_compliance(my_score_fn)
result.compliant        # True / False
result.compliance_rate  # 0.0 - 1.0

cert = certify(avg_v=0.12, health_rate=0.95, checks=150)
cert.name  # "Platinum"
```

**Wire Format** — any system producing this JSON is V-Score compatible:

```json
{
  "V": 0.019,
  "model": "qwen3-14b",
  "status": "THRIVING",
  "components": {"E": 0.82, "W": 0.60, "S": 0.50, "B": 0.87, "H": 0.09}
}
```

| Level | V | Health Rate | Checks |
|-------|--:|----------:|---------:|
| Platinum | >= 0.10 | >= 95% | >= 100 |
| Gold | >= 0.05 | >= 90% | >= 50 |
| Silver | >= 0.02 | >= 80% | >= 25 |
| Bronze | >= 0.01 | >= 60% | >= 10 |

---

## Why They Can't Copy This

| Feature | Why competitors can't |
|---------|----------------------|
| **Growth Rings** | Needs `tau` (time). Can't fast-forward lived experience. |
| **Cross-Model Collision** | They sell ONE model. Biodiversity = cannibalization. |
| **Anti-Addiction** | Their revenue = engagement. Saying STOP = losing money. |
| **Void Dreams** | No rings = no dreams. Can't dream without compound memory. |
| **Void Fingerprint** | Lock-in = their retention. Portability = losing users. |
| **Alignment by Architecture** | Rules can be jailbroken. Geometry can't. |

---

## Requirements

Python >= 3.10. Zero runtime dependencies.

```bash
pip install void-intelligence
```

Optional:
```bash
pip install void-intelligence[mcp]     # Claude Code plugin
pip install void-intelligence[mlx]     # Apple Silicon acceleration
pip install void-intelligence[all]     # Everything
```

## License

MIT — [Julian Guggeis / Guggeis Research](https://guggeis.de), 2026

---

```
.   x   ->   []   ~
```

*65% of frontier AI is dead. V-Score proves it. VOID fixes it. Then it dreams.*
