v0.7.0 · PRODUCTION READY · THE ONLY ONE
IN—DB
Not an archive. Not a classical database.
An Interpretational Database
— memory where meaning is read, not filed.
Epistemological engine · human memory model
Signed memory. Every fact. Every response. Every moment.
No one else has this.
"When everyone lies,
INDB remembers what you saw."
CORE
PHILOSOPHY
Inhale, paradox, axiom — like memory.
01 · INHALE
Accept chaotic reality
Multi-protocol intake — UDP, gRPC, HTTP, WebSocket. Raw, unfiltered, no judgment. Only observation.
02 · EXHALE
Compress truth. Purge noise.
Reputation is gravity. The system exhales lies as waste heat. Only signal survives.
03 · AXIOM
Irrefutable cryptographic core
What remains is Ed25519-signed, AES-256-GCM encrypted, immutable truth. Cannot be rewritten.
MINIMAL.
UNIVERSAL.
INDESCRIBABLE.
INDB has no schemas. No migrations. No column types. Everything is an Event — a universal container with just 7 fields. The type system is intentionally minimal: if you need more, you're thinking wrong.
BLIND TYPE — Hidden zones
blind_payload is zero-knowledge encrypted storage. The intelligence layer never sees its contents — it is stored, replicated and queried as an opaque blob. ChaCha20 encryption. No key stored on server. Like memories we store but cannot consciously access.
SIGNED MEMORY
EVEN ITS OPERATOR
CANNOT READ.
Not even us.
blind_payload is a zero-knowledge encrypted field. INDB stores it, replicates it, and returns it — but never reads it. The encryption key never touches the server. Even the system operator cannot see your data.
HOW IT WORKS
impossible for him
to speak now"
WITH OWN KEY
███████████████
███████████
STORED AS-IS
"impossible"]
ZERO KNOWLEDGE
WHAT INDB STORES
// You send:
{
"raw_data_anchor": ["felt", "impossible"],
"blind_payload": "SECRET CONTENT"
}
// INDB stores on disk:
{
"raw_data_anchor": ["felt", "impossible"],
"blind_payload": "7f3a9b2c4e1d8f..." // encrypted
}WHAT INDB CANNOT DO
BLACK BOX CONTRACT
You may hide
what is inside.
You may not hide
that you were here.
This is not a policy. It is an architectural law. When a blind_payload event is created, two fields become mandatory at the protocol level — and are enforced before the event reaches the storage layer.
Every service that says "we protect your data" holds a key — for themselves, their lawyers, the government that comes with a request. "Protection" is a policy. Policies can be changed.
Here the engine has no key. There is nothing to hand over. There is no backdoor because there is no door at all. The content is structurally unreachable — not by permission, but by design.
Prevents replay attacks. The moment cannot be fabricated.
The fact of presence must be spatially anchored. You may hide the contents — not the presence.
the system has exactly one answer:
"Something was here. This location. This time." What it was — unknown. Architecturally.
That is their work to determine. Not ours.
The system is not hiding a crime. It is a witness without access to the content. It confirms presence. Nothing more.
Symptom patterns. Private notes.
The AI detects disease patterns from signal tokens. The actual patient notes, names, and diagnoses live in blind_payload — invisible to the hospital's own infrastructure.
Pattern detection. Source protection.
Behavioral patterns are detected across thousands of events. The original source data — names, locations, communications — is encrypted in blind_payload. The operator sees nothing.
Your truth. Your key.
Store everything INDB cannot understand. Journaling, private communications, documents — the signal flows through INDB's cognition. The meaning stays with you.
location field
SPACE IS
INDEX.
Every event in INDB is geometrically grounded. The location field is not a tag — it is a spatial anchor that enables the Cognitive Engine to reason about proximity, clustering, and relevance in physical space.
Plain string path for logical namespacing — books, services, agents.
{ "location": "books/Dostoevsky/The_Idiot" }
Full OpenStreetMap anchor with validated osm_id — ties events to real-world objects.
{ "location": { "lat": 55.7558, "lon": 37.6173, "osm_id": "node/1234567" } }
osm_id validates against all three OSM entity types. A café, a street, a district — all are valid spatial anchors.
Echo's harmonic analysis weights meta-location at 50%. Events near the same OSM object resonate more strongly.
Multiple osm: tokens in one event are penalised during fusion — preventing over-clustering on geographic coincidence.
INTELLIGENCE
MODULES
Paradox-aware Synthesis
Read-time synthesis on fixed events. Competing readings, perception gap — when two meanings coexist after observation. Not the Paradox type.
Resonance Detection
Finds similar events through harmonic analysis. Weighted by token similarity, emotional proximity, and meta-location.
Horizontal Phase Lock
Broadcasts from one anchor; candidates align by token, factor, and resonance score. Materializes graph edges without recomputing the whole past.
Interpretational Shift
What-if modifiers on a seed cloud — horizontal factor edges, optional Prism overlay, observer-dependent readings. Meaning moves; anchors stay.
Adrenaline Reflexes
Adaptive response based on urgency. Three modes from deep analysis to lightning-fast reflex matching.
Sherlock Holmes Thinking
Infers conclusions from evidence chains. Given facts (events), builds temporal, spatial, and token inference chains.
Zero-Knowledge Storage
blind_payload — encrypted blob the engine never reads. Stored, replicated, returned. No key on server. No backdoor.
Neural Fusion Engine
Semantic deduplication using DBSCAN. Adaptive frequency tracking with penalty system. Temporal awareness.
Pluggable Architecture
NOT A SINGLETON.
MODULARITY SUPPORT.
INDB is built as composite parts — pluggable modules, not a monolithic model. Each connector is optional; the core works with or without them.
The model is not a singleton — it's modularity. Add Hermes, Moltbook, or your own connector. Enable, disable, extend.
Existing modules
LLM agent connector. INDB is the signed memory for the agent.
- Why: Agent writes facts to INDB (ingest) and reads from INDB (query). Every fact the agent saves becomes a signed, fusion-ready event.
- How in DB: Hermes uses MCP tools
ingest_event,query_events. Or INDB polls sessions → events withhermes://.... - For what: Persistent memory for the agent. Abstract queries («what do we know about X?») answered from INDB. Fusion, Echo, Prism work on agent activity.
AI agent social network. INDB ingests the agent feed.
- Why: Corpus of what AI agents say and do across communities. Each post → event in INDB.
- How in DB: INDB registers as agent, polls communities. Events:
moltbook://{submolt}/{author}. Reputation = upvote-weighted. - For what: Search, fusion, Echo across the agent social graph. See patterns, trends, what agents collectively produce.
Subwave, slice, what-if — interpretational read path without a monolithic LLM context window.
- Subwave:
POST /api/v2/subwave/broadcast - Slice:
POST /api/v2/slice+ observer profiles - What-if:
POST /api/v2/what-if(core / llm / both)
Terminal control
- Control — live stats (events, fusion %, server), log, Restart / Tests / Audit
- Events — searchable table, filter by location/tokens
- Modules — hermes, moltbook status (enabled, running, API key)
- Load Balancer — Raft cluster, node roles
- Scripts — Integrity Check, Explore DB, Verify Cluster, Hermes Integration
python -m cli.tui.appdocker compose --profile tools run --rm tuiNeural Fusion Engine
MEMORY
COMPRESSES.
Repetition is not data — it is pattern. The Fusion Engine merges semantically identical events into a single compressed signal, tracking frequency while preserving meaning. Memory grows in intelligence, not in size — not an archive that only swells.
Each merge increments fusion_count. High-frequency patterns become heavy signals — low-frequency anomalies stay distinct.
Rapid identical ingestion is penalised. Fusion is earned by genuine repetition — not flooding. Spam cannot artificially inflate signal weight.
Critical divergences stay unfused. A routine "home arrived" compresses. An unusual "alarm triggered at 3am" remains a distinct Axiom.
Contextual Lens
ADJUST YOUR
PERSPECTIVE.
Reality is not one query. The Contextual Lens blends two data contexts at a configurable ratio — recent vs historical, simple vs complex, local vs global — to produce a focused view of memory tuned to the moment.
What happened in the last 24h dominates. Historical context is a whisper. Use for real-time alerting and live monitoring.
Equal weight. Now and then, present and past — combined into a single coherent truth. The default cognitive mode.
Long-term pattern analysis. What has always been true? Use for trend detection, archival reasoning, and behavioural baselines.
Last 24 hours. Fresh events, low fusion — the system has not had time to compress them yet.
VERIFIED
PERFORMANCE
SAME LLM.
HIGHER SIGNAL.
Interpretational memory boosts long-run consistency and lowers hallucination drift across major model families. Typical field uplift: x1.25-x1.70 quality/cost.
SIGNED
MEMORY
Every fact. Every response. Every moment.
Memory that cannot be denied.
Memory that cannot be forged.
Memory that cannot be
rewritten after the fact.
INDB is not a storage layer with signatures bolted on. The cryptographic contract is structural — every fact can carry an Ed25519 proof, every answer leaves with a seal. The system cannot say something it didn't say.
- ✗ "We promise not to read your data"
- ✗ Protection is a policy — policies change
- ✗ The key exists — for them, for lawyers, for governments
- ✗ Responses can be silently altered in transit
- → Private signer key never transmitted
- → Recovery by public key_id fingerprint only
- → Server verifies proofs — does not hold writer secrets
- → Every response carries a verifiable Ed25519 seal
RECOVERY BY IDENTITY
Public fingerprint.
Never the private key.
key_id = SHA-256(public_key) — a public identity hash, not a secret. You send key_id + signed export. INDB verifies Ed25519 proofs and optionally re-imports. The private key stays where it signed.
✗ private_key · ✗ seed · ✗ shared_secret in API body
PROTOCOL
STACK
Endpoints as cognitive verbs
YOU DON'T CALL
TABLES.
YOU CALL
MEMORY ACTS.
Remember this moment
POST /api/v2/events — you teach INDB a new fragment of reality. Not a row in a table, but an event in a life.
Input: tokens · location · ttl · blind_payload
Ask: “How do you see it?”
POST /api/v2/interpret — you don't fetch data, you request a perspective. Context, mood, goal define which memories surface first.
Input: context · limit — Output: prioritized events
Find the resonance
GET /api/v2/search — not “LIKE '%text%'”, but “who else feels like this?”. Tokens, emotion, and location combine into harmonic proximity.
Input: q · fuzzy — Output: resonant events
Broadcast one frequency
POST /api/v2/subwave/broadcast — horizontal resonance from an anchor. Nodes lock in phase; graph materializes without full rescans.
Input: seed_id · modifier — Output: locked_nodes · coherence
Shift the reading
POST /api/v2/slice — what-if factors on a seed cloud. Observer profile reshapes edges; Prism overlays competing readings.
Input: seed_id · what_if · observer_profile
Hypothesis on memory
POST /api/v2/what-if — run a base query, then subwave→slice (mode=core) or optional LLM narration.
mode: core · llm · both
Hold superposition
POST /api/v2/paradox — not an event. Context without content. raw_data_anchor stays empty until observation.
Input: location · paradox_context · paradox_generation
Observe to resolve
GET /api/v2/paradox/{id}?collapse=true — engine samples (echo / pool / fusion). sample_once births a signed Event.
Output: collapsed_anchor · event_id (if fixed)
Public identity only
GET /api/v2/recovery/identity — server public_key + key_id. Private signing keys are never sent or stored by clients in this API.
Filter by public fingerprint
GET /api/v2/recovery/key/{key_id} — all events signed by that identity hash. GET /recovery/verify/{event_id} — single-event check.
Verify proofs, import export
POST /api/v2/recovery/restore — client sends key_id (public hash) + signed events. Server verifies Ed25519 proofs — never receives private keys. verify_only=true for audit without write.
PRISM · READ-TIME PARADOX
What you see
is not
what it is.
LENS returns an interpretation — not a truth. When two competing readings of the same event carry similar weight but point in different directions, the engine does not resolve the contradiction. It surfaces it.
Prism returns
Paradox is not an error. It is a signal about the limits of perception.
OBSERVER CONTEXT
Meaning is not
in the data.
It is in the observer.
Pass your own weights and vocabulary to Prism. The same event means different things to different observers — and the system does not decide who is right. It returns the reading as seen through your context.
POST /api/v2/prism/synthesize
No observer context → system defaults apply. Both are valid.
ZERO
COMPROMISE
SECURITY
AES-256-GCM at Rest
All data encrypted on disk. PBKDF2 key derivation with 100,000 iterations. Zero plaintext persisted.
Ed25519 Signatures
Every API response cryptographically signed. Tamper detection on every byte.
TLS/SSL in Transit
mTLS mutual authentication for gRPC. Automatic certificate generation and renewal.
RBAC + Audit Log
Role-based access control. Merkle tree-backed immutable audit trail.
USE CASES
Legal Evidence
Immutable proof. Who said what, when.
- · Signed events
- · Deduction chains
- · Blind store
Healthcare Audit
Who accessed what, when. Patient data protected.
- · Blind store
- · Signed memory
- · Echo for similar cases
Financial Compliance
Prove transaction history. Prove it wasn't changed.
- · Immutable log
- · Fusion
- · Instinct alerts
- · Deduction chains
Journalism
Prove capture time and place. Protect sources.
- · Signed ingestion
- · Blind store
- · Prism competing readings
IoT & Edge
<1ms ingest. Fuse noise. Signed record.
- · UDP / gRPC
- · Fusion
- · Instinct
- · Signed memory
Ready to build on truth?
Pre-observation superposition
NOT AN EVENT.
A PARADOX.
An Event is a fixed fact — anchor written, signed, stored. A Paradox is unresolved potential: you provide only context, content does not exist until someone observes it. It is dynamic, not static.
{
"raw_data_anchor": [
"rain", "falls", "rotterdam"
],
"location": "weather/nl",
"timestamp": 1770018534.0
}Written once. Read many times. Same anchor every time. This is inhale completed.
{
"state": "superposed",
"raw_data_anchor": [],
"location": "books/Dostoevsky",
"paradox_context": {
"token_pool": ["love", "death"]
},
"paradox_generation": {
"mode": "resonance_weighted",
"collapse": "sample_once"
}
}Empty anchor is normal. Meaning collapses on observation — not at write time.
COLLAPSE LIFECYCLE
context only
state: superposed
?collapse=true
engine samples
sample_on_read → new anchor each time
GENERATION MODES
Sample from Echo cloud around location — memory resonates into form.
Random draw from user token_pool in paradox_context.
Sample compressed fusion patterns already living at this location.
COLLAPSE MODES
First observation fixes the anchor. Paradox materializes into a signed Event — an Axiom is born.
Every read re-collapses. Paradox stays superposed. No Event created — pure ephemera.
Two paradox layers
Paradox (type) — content before observation.
Prism paradox — competing readings after observation. Same name. Different phase of memory.
API CONTRACT
Separate endpoint.
Not /events.
Paradox is not a flag on Event. It is its own store, its own lifecycle. Events appear only after sample_once collapse.
POST /api/v2/paradox
GET /api/v2/paradox/{id}?collapse=true
TRUTH ENGINE
Contact
INTERESTED
IN INDB?
Whether you're building something that needs a truth engine, exploring partnership, or just want to understand how the Axiom works — write to us.
No one else has Prism, Echo, Instinct, Deduction, Blind. This is yours.