void-intelligence 3.3.0

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.

VOID Intelligence

.   x   ->   []   ~

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

---

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.

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.

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

---

Quick Start

pip install void-intelligence

The Organism

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.

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:

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.

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)

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.

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

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.

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

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.

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

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.

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)

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.         │
└─────────────────────────────────────────────────────────────────┘

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.

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.

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.

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

pip install void-intelligence[mcp]

Add to .mcp.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

# 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)

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:

{
  "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.

pip install void-intelligence

Optional:

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, 2026

---

.   x   ->   []   ~

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