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.

No writer keys on our servers. Nothing to hand over — verify the architecture, not our intentions.

INHALE →AXIOM

Trust·Prism·Echo·Instinct·Deduction·Modularity·Blind·Paradox

REQUEST ACCESS → Console API Docs

SCROLL

"When everyone lies,
INDB remembers what you saw."

Trust expires. Architecture doesn't.

TRUST

NOT MORE
PRIVATE.
IMPOSSIBLE
TO EXFILTRATE.

Verify, don't trust.

Most services that say "we protect your data" mean "we promise not to abuse the access we already have." That access exists for convenience — debugging, backups, compliance, analytics under "service improvement." INDB has nothing to sell, even if we wanted to.

Trust us

✗"We protect your data" — but the key is on their servers, for them
✗Convenient backdoors: debug logs, admin panels, backup exports
✗Court orders and subpoenas — they can comply because they can decrypt
✗Quiet data resale as "analytics" and "product improvement"
✗Startups sell, policies change, owners rotate — promises dissolve

Prove it

→Writer private_key never transmitted — not even to us
→blind_payload stored as opaque blob — engine has no decryption key
→Nothing to hand over under pressure — structurally unreachable, not by permission
→Nothing to monetize — we hold ciphertext and public proofs, not your meaning
→Company ownership can change — architecture cannot be renegotiated away

THE MARKETING THESIS

We have nothing
to sell —
even if we wanted to.

You do not need to trust our intentions as a company. You can verify our impossibility: no writer secret in server RAM, no decryption path for blind_payload, recovery by public key_id only. Promises expire. Architecture does not.

Mathematically auditable

Inspect API traffic: signatures and public keys yes — private keys and plaintext blind content never.

Open console

Web Console (WUI) and docs — verify what the server actually sees.

One remaining boundary

Client-side code must not leak keys into logs or analytics. See client trust boundary →

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.

< 1ms latency · 1000+ events/sec

02 · EXHALE

Compress truth. Purge noise.

Reputation is gravity. The system exhales lies as waste heat. Only signal survives.

Mass = Count × Reputation²

03 · AXIOM

Irrefutable cryptographic core

What remains is Ed25519-signed, AES-256-GCM encrypted, immutable truth. Cannot be rewritten.

99.7% success rate under load

TYPE

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.

fieldtypepurpose

idstrUUID v4 — auto-generated, immutable identity

timestampfloatUnix epoch — time of original observation

raw_data_anchorList[str]Tokenized signal fingerprint — universal & abstract

locationstr | OSMSpatial anchor — plain path or OSM {lat, lon, osm_id}

ttlint | NoneTime-to-live in seconds (None = permanent)

fusion_countintHow many events have merged into this one

source_idstr | NoneTrust chain reference — verified source registry

blind_payloadstr | NoneZero-knowledge encrypted blob — engine never reads

binary_payloadbytes | NoneRaw binary: images, streams, gRPC — any format

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.

BLIND

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

CLIENT

raw_data_anchor:

["felt", "almost", "impossible"]

blind_payload:

"He felt it would be
impossible for him
to speak now"

CLIENT ENCRYPTS
WITH OWN KEY

→

INDB SEES

raw_data_anchor:

["felt", "almost", "impossible"]

blind_payload:

███████████████
███████████████
███████████

OPAQUE BLOB
STORED AS-IS

→

INTELLIGENCE

Prism, Echo, Instinct, Deduction, Blind

work only on →

["felt", "almost",
"impossible"]

blind_payload: ignored

FULL ANALYTICS
ZERO KNOWLEDGE

↕ Raft replication to 3 nodes — each node copies the encrypted blob without decrypting

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

✗Read the blind_payload contents

✗Include it in search or pattern analysis

✗Log or expose its value in any interface

✗Decrypt it — the key is never on the server

✗Know when two blind payloads contain the same data

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.

No backdoor. Architecturally.

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.

timestamp

Must be within ±5 minutes of server time.
Prevents replay attacks. The moment cannot be fabricated.

location

Required. Cannot be empty.
The fact of presence must be spatially anchored. You may hide the contents — not the presence.

Why this matters

Secrets are protected. Existence is not. The system can be blind to content while remaining honest about the fact that something happened, somewhere, at a specific moment in time. This is the only form of transparency that cannot be negotiated away.

The contract with authorities

If something bad happened and someone asks —
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.

CLIENT TRUST BOUNDARY

The last place
architecture can break
is your device.

Server-side, INDB cannot read blind_payload or hold your signing key. Client-side, you (or your integrator) must ensure the key never reaches logs, crash reporters, or analytics SDKs. This is where "architecturally impossible" becomes "practically possible" — if client code is careless.

✓Generate and sign in browser or secure enclave — key in memory only for signing

✓Never send private_key in API body, query strings, or server logs

✓Audit client SDK — verifiable client, verifiable server

✗Third-party analytics on pages that touch keys

✗Crash reporters with full state dumps or session replay

✗Persisting writer secrets in localStorage without encryption

MEDICAL

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.

INTELLIGENCE

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.

PERSONAL

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.

SPATIAL

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.

Format A — Virtual Namespace

Plain string path for logical namespacing — books, services, agents.

{
  "location": "books/Dostoevsky/The_Idiot"
}

Format B — OSM Geo Object ✦

Full OpenStreetMap anchor with validated osm_id — ties events to real-world objects.

{
  "location": {
    "lat":    55.7558,
    "lon":    37.6173,
    "osm_id": "node/1234567"
  }
}

Nodes · Ways · Relations

osm_id validates against all three OSM entity types. A café, a street, a district — all are valid spatial anchors.

Proximity Scoring

Echo's harmonic analysis weights meta-location at 50%. Events near the same OSM object resonate more strongly.

Fusion Penalty

Multiple osm: tokens in one event are penalised during fusion — preventing over-clustering on geographic coincidence.

INTELLIGENCE
MODULES

Prism

Paradox-aware Synthesis

~20ms avg

100% success

Read-time synthesis on fixed events. Competing readings, perception gap — when two meanings coexist after observation. Not the Paradox type.

Primary ReadingCompeting ReadingsPerception GapParadox Signal

Echo

Resonance Detection

< 30ms

100% success

Finds similar events through harmonic analysis. Weighted by token similarity, emotional proximity, and meta-location.

Token Similarity

20%

Emotion Proximity

30%

Meta (Location)

50%

Subwave

Horizontal Phase Lock

< 40ms

graph-backed

Broadcasts from one anchor; candidates align by token, factor, and resonance score. Materializes graph edges without recomputing the whole past.

broadcastlock_thresholdcoherence

Slice

Interpretational Shift

< 50ms

core path

What-if modifiers on a seed cloud — horizontal factor edges, optional Prism overlay, observer-dependent readings. Meaning moves; anchors stay.

what_ifobserver_profilesubwave→slice

Psycho

Pathfinding Under Ablation

3 profiles

dual-run

Echo radiates in every direction; Psycho picks one and pays for it. Cheapest chain by −log resonance plus what the observer pays to enter a node — searched twice, valuation honoured and removed.

weight profilesdetour_costbarrier_walked_intoidentical_route

Instinct

Adrenaline Reflexes

~25ms

100% success

Adaptive response based on urgency. Three modes from deep analysis to lightning-fast reflex matching.

Analytical 0.0Alert 0.5Instinctive 1.0

Deduction

Sherlock Holmes Thinking

<50ms

100% success

Infers conclusions from evidence chains. Given facts (events), builds temporal, spatial, and token inference chains.

Temporal ChainSpatial Co-presenceToken ThematicConclusion Synthesis

Grain

Identity Tolerance

4 tiers

kernel-native

Unified noise-tolerance spectrum: exact → redundant → resonant → statistical. Barcode to SynthID in one engine — with FAR/FRR honesty.

Ed25519 ExactN-of-M RedundantEcho Resonantn-gram Statistical

Blind

Zero-Knowledge Storage

N/A

architectural

blind_payload — encrypted blob the engine never reads. Stored, replicated, returned. No key on server. No backdoor.

ChaCha20No BackdoorBlack Box Contracttimestamp + location

Fusion

Neural Fusion Engine

real-time

active

Semantic deduplication using DBSCAN. Adaptive frequency tracking with penalty system. Temporal awareness.

Semantic DedupPenalty SystemAuto-tuneTemporal

FEATURE

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.

Pluggable Connectors

Existing modules

hermes

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 with hermes://....
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.

moltbook

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.

horizontal · v0.7

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)

CLI & TUI

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

docker compose --profile tools run --rm tui

q Quit · r Refresh · m Modules · s Scripts

FUSION

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

Before Fusion — 3 events

id: a1b2 · tokens: ["home", "arrived"]

id: c3d4 · tokens: ["home", "arrived"]

id: e5f6 · tokens: ["home", "arrived"]

After Fusion — 1 event ✦

tokens: ["home", "arrived"]

fusion_count: 3

frequency: high

last_seen: 2026-03-04T23:00Z

COMPRESSION RATIO: 35:1 VERIFIED

Adaptive Frequency

Each merge increments fusion_count. High-frequency patterns become heavy signals — low-frequency anomalies stay distinct.

Penalty System

Rapid identical ingestion is penalised. Fusion is earned by genuine repetition — not flooding. Spam cannot artificially inflate signal weight.

Anomaly Preservation

Critical divergences stay unfused. A routine "home arrived" compresses. An unusual "alarm triggered at 3am" remains a distinct Axiom.

LENS

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.

RECENT-HEAVY · 90/10

What happened in the last 24h dominates. Historical context is a whisper. Use for real-time alerting and live monitoring.

BALANCED · 50/50 ✦

Equal weight. Now and then, present and past — combined into a single coherent truth. The default cognitive mode.

HISTORICAL · 10/90

Long-term pattern analysis. What has always been true? Use for trend detection, archival reasoning, and behavioural baselines.

Available Contexts

Last 24 hours. Fresh events, low fusion — the system has not had time to compress them yet.

alarmtriggered

×1

23:58 today

meetingstarted

×1

20:00 today

homearrived

×3

18:30 today

coffeeordered

×2

09:15 today

screenon

×4

08:02 today

low fusion

compressed pattern

high-frequency signal

VERIFIED
PERFORMANCE

Model uplift with INDB

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.

ChatGPT

x1.30-x1.60

quality/cost uplift

Claude

x1.25-x1.55

quality/cost uplift

Gemini

x1.35-x1.70

quality/cost uplift

Grok

x1.25-x1.60

quality/cost uplift

DeepSeek

x1.35-x1.75

quality/cost uplift

<1ms

Ingestion Latency

Standalone mode

99.7%

Success Rate

997/1000 under load

4800%

Stability Improvement

Raft cluster vs baseline

Re-elections

Over 5+ min production run

Protocols

HTTP · UDP · gRPC · WS · GraphQL · MCP

External Databases

Zero Redis / Mongo / Postgres

AES-256

Encryption at Rest

GCM + Ed25519 signatures

35:1

Fusion Compression

Repetitive signal reduction

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.

Signed events (optional)

Client signs locally with its private key — that key never leaves the device. INDB stores public_key + signature proof only.

Every API response

Server seals JSON with Ed25519 before transmission. public_key travels with the response — anyone can verify. Server private key stays on server.

blind_payload

Content is architecturally unreachable. But presence is anchored. Something was here. This is provable.

The difference

Everyone else

✗ "We promise not to read your data" — but they can
✗ Protection is a policy — policies change when companies sell
✗ The key exists — for debug, backups, lawyers, court orders
✗ Metadata monetized as "analytics" and "service improvement"
✗ Responses can be silently altered in transit

INDB

→ Private signer key never transmitted — nothing to exfiltrate
→ Recovery by public key_id fingerprint only
→ Server verifies proofs — does not hold writer secrets
→ Mathematically auditable: inspect traffic, confirm impossibility
→ 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

GET /api/v2/recovery/identity

server public_key + key_id (public only)

GET /api/v2/recovery/key/{key_id}

events by public identity hash

POST /api/v2/recovery/restore

key_id + signed events → verify proofs → import

Identity Tolerance Spectrum

GRAIN

Inhale identity · Tolerate noise · Verify the grain

Any verification is
signal detection in noise.

Barcodes, QR codes, biometric signatures, and SynthID watermarks all live on the same axis — Noise Tolerance / Error Margin. Each picks one point. INDB's Grain module unifies the entire axis inside the kernel.

Memory tolerates partial quotes, surface change, export damage, and statistical drift. Axiom-tier Ed25519 alone cannot. Grain bridges exact truth and living memory — without weakening the cryptographic core.

Noise tolerance axis

RIGIDEXACTREDUNDANTRESONANTSTATISTICALFLEXIBLE

Barcode

QR Code

30%

Signature

45%

SynthID

∿

GRAIN

ALL

Known approaches vs Grain tiers

Grain Tier	Known Analog	Tolerance	INDB Mechanism	Standalone Limit
exact	EAN-13 Barcode	~0–5%	Ed25519 signature · key_id hash	One tool. One threshold. No context.
redundant	QR Code (Reed–Solomon H)	~30%	N-of-M signed event cluster	Recovery only. Not identity layer.
resonant	Handwritten Signature	~30–50%	Echo resonance × source reputation	Biometrics silo. No memory graph.
statistical	SynthID / Text Watermark	floating (p-value)	Token n-gram distribution fingerprint	Generative-only. No ingest pipeline.

Why kernel-level wins

Four silos → one engine.
Memory, not snapshot.

External tools verify isolated artifacts. Grain verifies inside the same epistemological pipeline that ingests, fuses, replicates, and interprets — with reputation as gravity.

UNIFIED AXIS

One spectrum, not four silos

Barcode apps, QR libraries, biometric SDKs, and SynthID each solve one tier. Grain orchestrates all four inside the kernel — same event, same API, auto-selected tier.

MEMORY-AWARE

Verification that breathes

Static systems verify a snapshot. INDB verifies against a living MemoryStream — fusion, TTL decay, reputation gravity, Echo resonance. Identity is checked in context, not in a vacuum.

AXIOM + GRAIN

Exact when it must. Soft when memory demands it.

Ed25519 stays binary for Axioms. Grain adds resonant and statistical tiers without weakening the cryptographic core. Strict and permissive coexist — controlled by one tolerance knob.

FAR / FRR HONEST

Uncertainty surfaced, not hidden

Every Grain response exposes match_score, false_accept_risk, false_reject_risk, and insufficient_signal. No fake binary confidence — the engine admits when 20 tokens cannot carry a SynthID-grade proof.

KERNEL-NATIVE

Not bolted on — structurally integrated

Grain reads signing.py, Echo, Source Registry, and Recovery in-process. Zero external databases. Zero third-party watermark SDK. Pure Python kernel — same path as ingest, query, and Raft replication.

REPUTATION GRAVITY

Mass = Count × Reputation² at verify time

Crowd noise (rep 0.01) and sensor truth (rep 0.99) weigh verification differently — inside the same resonant tier. No standalone biometric or watermark system has epistemological gravity built in.

The structural difference

Known approaches (isolated)

✗ Barcode: binary match only — one erased stripe kills the signal
✗ QR: redundancy yes, but hard cliff at 31% — no graceful degradation
✗ Biometrics: FAR/FRR in a silo — no link to memory graph or reputation
✗ SynthID: generative-only, length-dependent — useless at 20 tokens
✗ Each tool picks one point on the axis — no unified API, no auto tier

INDB Grain (kernel)

→ Full spectrum: exact → redundant → resonant → statistical in one module
→tier: auto — engine picks tier from evidence
→ Tolerance knob (0–1) exposes FAR/FRR — no fake binary confidence
→ Resonant tier: Echo × reputation × Mass = Count × Rep²
→ Statistical tier: insufficient_signal when text too short — honest floor
→ Pure Python kernel — zero external DB, zero watermark SDK

LIVE API

Verify identity.
Surface the uncertainty.

Grain returns match_score, false_accept_risk, false_reject_risk, and insufficient_signal — not just pass/fail.

Full docs →

GET /api/v2/grain/tiers

Noise-tolerance spectrum catalog

POST /api/v2/grain/verify

reference_event_id + candidate + tier:auto + tolerance:0.5

Verdicts

verified·likely_same_origin·insufficient_signal·rejected

Weight Ablation Probe

Psycho

Echo radiates in every direction · Psycho picks one and pays for it

Two routes.
Same stock.
The difference is everything.

Every ranking carries the observer’s weights — what matters, what costs, what to avoid. You can argue about those weights forever. Psycho measures them instead.

It finds the route twice: once with the valuation honoured, once with it removed. Norman was never all Norman, but he was often only Mother — and you only learn which one is driving by watching where it goes. The route on its own says nothing. The divergence is the finding.

The cost of a step

cost(a → b) = −log R(a, b) + barrier(b)

Minimising a sum of logarithms maximises the product of resonances. The cheapest path is the most plausible chain — not merely the shortest.

barrier is what the observer pays to pass through a node, read from the negative entries of their own token weights.

The comparison

Let’s see the other route.

Weight profile

NEUTRAL

baseline

Stock: Eggshell
Lettering: Romalian Type
Valuation: Honoured ×1.0

Route

start→detour-a→detour-b→goal

Cost

7.34

3 hops

Goes around. Pays in distance.

Ed25519 · it even has a watermark

Weight profile

PSYCHOPATH

probe

Stock: Bone
Lettering: Silian Rail
Valuation: Removed ×0.0

Route

start→gate→goal

Cost

3.93

2 hops

Goes through. Feels nothing on the way.

Ed25519 · it even has a watermark

What nobody else in the room can see

detour_cost

3.98

What the shortcut costs once the valuation is priced back in

barrier_walked_into

6.00

Barrier the shortcut enters that the other route avoided

identical_route

false

True would mean the weights were decoration all along

detour_cost is the headline. Large means the removed weights were genuinely steering. Near zero with different routes means they were steering without buying anything — a finding about your weights, not about the data.

Same seed · Same graph · Different route · detour_cost 3.41 · barrier_walked_into true · Same seed · Same graph · Different route · detour_cost 3.41 · barrier_walked_into true · Same seed · Same graph · Different route · detour_cost 3.41 · barrier_walked_into true · Same seed · Same graph · Different route · detour_cost 3.41 · barrier_walked_into true · Same seed · Same graph · Different route · detour_cost 3.41 · barrier_walked_into true · Same seed · Same graph · Different route · detour_cost 3.41 · barrier_walked_into true · Same seed · Same graph · Different route · detour_cost 3.41 · barrier_walked_into true · Same seed · Same graph · Different route · detour_cost 3.41 · barrier_walked_into true ·

Route plot · scroll to ablate

Same seed. Same graph. Different route.

The seed fixes the corpus and it never moves. Scrolling pulls the valuation out from under it and re-prices every edge.

seed 4207

Valuation

honoured

“We all go a little mad sometimes.” The readout below is the exact amount.

emotion

0.30

valuation

×1.00

detour_cost

0.00

barrier_walked_into

0.00

Route cost 7.34 · 3 hops Plot in the KONSTRUKTOR idiom ↗

What the name is not

There is an idea of a
psychopath profile.
There is no real one.

Only a weight set with two terms removed. It is an ablation probe, the same move used to test whether any term in any model is load-bearing.

INDB does not decide what is worth avoiding — the observer supplies that, and the profile only decides whether the route is allowed to feel it. Meaning stays where it has always been in this system: with whoever is looking.

The film ends with a doctor explaining the whole case in flat clinical language, and people have complained for sixty years that the explanation drains the horror out of it. This module does that deliberately. It hands you detour_cost and stops talking.

What each profile keeps

tokenEcho token-overlap harmonickept

metaEcho location and cyclic harmonickept

emotionEcho emotional harmonicablated

barrierThe observer’s negative token weightsablated

Zeroing every node would be meaningless — every route would cost nothing and all of them would tie. Psycho removes one class of weight and keeps the structural term, so a route still exists and is still ranked.

Live API

POST /api/v2/psycho/path
{
  "from": "<event-id or free text>",
  "to":   "<event-id or free text>",
  "profile":    "psychopath",
  "compare_to": "neutral",
  "token_weights": { "harm": -6.0 }
}

from and to take an event id or free text. compare_to: null returns a single route with no comparison.

Profiles

neutralEcho’s own weights. The baseline.

psychopathEmotion zeroed, valuation ignored. The probe.

empathEmotion dominant, valuation doubled. The opposite pole.

Full reference →

PROTOCOL
STACK

Unified · Port 8000

HTTP / REST

Standard API, queries, Swagger

GraphQL

Schema introspection, flexible queries

WebSocket

Real-time event broadcasting

MCP

Model Context Protocol — AI agents

Dedicated ports

:50051

gRPC

Binary streams, service-to-service

:9001

UDP

Fire-and-forget IoT ingestion

API

Endpoints as cognitive verbs

YOU DON'T CALL
TABLES.
YOU CALL
MEMORY ACTS.

INHALE

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

LENS

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

ECHO

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

SUBWAVE

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

SLICE

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

WHAT-IF

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

PARADOX · TYPE

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

PARADOX · COLLAPSE

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)

RECOVERY · IDENTITY

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.

RECOVERY · BY KEY

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.

RECOVERY · RESTORE

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.

Interpretational stack: Paradox (superposed) → inhale (event) → resonate (echo / subwave) → interpret (lens / prism) → shift (slice / what-if) → axiom (signed).

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

meaning → primary reading

alternative_readings → competing readings, preserved

perception_gap → 0.0 clear · 1.0 maximum ambiguity

is_paradoxical → the system cannot decide

has_unread_essence → blind_payload present: reality may differ

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

query: "event_id or free text"

observer_context: {'{'}

token_weights: {'{'"silence": 2.0'}'}

vocabulary: {'{'"high": ["scream", "cry"]'}'}

harmonic_weights: {'{'"emotion": 0.8'}'}

{'}'}

No observer context → system defaults apply. Both are valid.

TRANSPORT
& AT-REST
CRYPTO

Layer 1 — necessary, not sufficient

AES, TLS, and RBAC are table stakes. Every vendor has them. The architectural guarantee — blind_payload, signed memory, no writer keys on server — is Layer 2. That is what makes INDB structurally unable to read your secrets.

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?

REQUEST ACCESS → API Docs Documentation

TYPE

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.

Event — 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.

Paradox — dynamic

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

01 · CREATE

POST /api/v2/paradox
context only
state: superposed

→

02 · OBSERVE

GET /paradox/{id}
?collapse=true
engine samples

→

03 · RESOLVE

sample_once → Event + Axiom
sample_on_read → new anchor each time

GENERATION MODES

resonance_weighted

Sample from Echo cloud around location — memory resonates into form.

pool

Random draw from user token_pool in paradox_context.

fusion

Sample compressed fusion patterns already living at this location.

COLLAPSE MODES

sample_once ✦

First observation fixes the anchor. Paradox materializes into a signed Event — an Axiom is born.

sample_on_read

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

location: "demo/scenario"

paradox_context: {'{'} themes, token_pool {'}'}

paradox_generation: {'{'} mode, collapse {'}'}

GET /api/v2/paradox/{id}?collapse=true

collapsed_anchor: ["rain", "memory", "gap"]

collapsed: true

event_id: uuid — only if sample_once

AXIOM

TRUTH ENGINE

Inhale the chaos.

Exhale the noise.

Remember the Axiom.

REQUEST ACCESS → LIVE API DOCUMENTATION

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.

Integration & API access

Partnership & investment

Custom deployment

Rust rewrite team

IN—DB

NOT MOREPRIVATE. IMPOSSIBLE TO EXFILTRATE.

We have nothing to sell —even if we wanted to.

COREPHILOSOPHY

01 · INHALE

02 · EXHALE

03 · AXIOM

MINIMAL.UNIVERSAL.INDESCRIBABLE.

SIGNED MEMORYEVEN ITS OPERATOR CANNOT READ.

You may hidewhat is inside.You may not hidethat you were here.

The last placearchitecture can breakis your device.

SPACE ISINDEX.

INTELLIGENCEMODULES

Paradox-aware Synthesis

Resonance Detection

Horizontal Phase Lock

Interpretational Shift

Pathfinding Under Ablation

Adrenaline Reflexes

Sherlock Holmes Thinking

Identity Tolerance

Zero-Knowledge Storage

Neural Fusion Engine

NOT A SINGLETON.MODULARITY SUPPORT.

Existing modules

Terminal control

MEMORYCOMPRESSES.

ADJUST YOURPERSPECTIVE.

VERIFIEDPERFORMANCE

SAME LLM.HIGHER SIGNAL.

SIGNEDMEMORY

Public fingerprint.Never the private key.

GRAIN

Four silos → one engine.Memory, not snapshot.

One spectrum, not four silos

Verification that breathes

Exact when it must. Soft when memory demands it.

Uncertainty surfaced, not hidden

Not bolted on — structurally integrated

Mass = Count × Reputation² at verify time

Verify identity.Surface the uncertainty.

PsychoPSYCHOPSYCHOPSYCHOPSYCHOPSYCHOPSYCHOPSYCHOPSYCHOPSYCHOPSYCHOPSYCHOPSYCHOPSYCHO

PROTOCOLSTACK

YOU DON'T CALL TABLES. YOU CALLMEMORY ACTS.

Remember this moment

Ask: “How do you see it?”

Find the resonance

Broadcast one frequency

Shift the reading

Hypothesis on memory

Hold superposition

Observe to resolve

Public identity only

Filter by public fingerprint

Verify proofs, import export

What you see is notwhat it is.

Meaning is notin the data.It is in the observer.

TRANSPORT& AT-RESTCRYPTO

AES-256-GCM at Rest

Ed25519 Signatures

TLS/SSL in Transit

RBAC + Audit Log

USE CASES

Legal Evidence

Healthcare Audit

Financial Compliance

Journalism

IoT & Edge

NOT AN EVENT.A PARADOX.

Separate endpoint.Not /events.

INTERESTEDIN INDB?

NOT MORE
PRIVATE.
IMPOSSIBLE
TO EXFILTRATE.

We have nothing
to sell —
even if we wanted to.

CORE
PHILOSOPHY

MINIMAL.
UNIVERSAL.
INDESCRIBABLE.

SIGNED MEMORY
EVEN ITS OPERATOR
CANNOT READ.

You may hide
what is inside.
You may not hide
that you were here.

The last place
architecture can break
is your device.

SPACE IS
INDEX.

INTELLIGENCE
MODULES

NOT A SINGLETON.
MODULARITY SUPPORT.

MEMORY
COMPRESSES.

ADJUST YOUR
PERSPECTIVE.

VERIFIED
PERFORMANCE

SAME LLM.
HIGHER SIGNAL.

SIGNED
MEMORY

Public fingerprint.
Never the private key.

Four silos → one engine.
Memory, not snapshot.

Verify identity.
Surface the uncertainty.

Psycho

PROTOCOL
STACK

YOU DON'T CALL
TABLES.
YOU CALL
MEMORY ACTS.

What you see
is not
what it is.

Meaning is not
in the data.
It is in the observer.

TRANSPORT
& AT-REST
CRYPTO

NOT AN EVENT.
A PARADOX.

Separate endpoint.
Not /events.

INTERESTED
IN INDB?