Durable authority
A checksummed, digest-chained append-only log owns the truth. Embedded indexes are rebuildable.
Autonomous Rust data engine
Data thatcan prove itself.
One binary. One data directory. Durable KV, structured query, exact vector, lexical, and hybrid retrieval—with proofs that reexecute offline.
Provider-free lexical retrieval joins deterministic data operations in Hyphae 0.2.0.
APPENDRECOVERQUERYPROVEVERIFY OFFLINE
What Hyphae does
Local data without invisible dependencies.
The base product is useful before a network, model, control plane, or managed service enters the architecture.
Structured query
Deterministic filters, global sorting, logical cursors, and aggregations run with hard budgets.
Durable retrieval
Named Q15 vector spaces and provider-free lexical indexes survive recovery, backup, restore, and compaction.
Recover deliberately
Snapshots, compaction generations, backups, restore, and doctor expose complete evidence.
Fuse deterministically
Hybrid retrieval combines complete vector and lexical rankings with integer reciprocal-rank fusion.
Prove every mode
Separate result and retrieval proofs reexecute offline against a pinned anchor and snapshot witness.
New in 0.2.0
Three retrieval modes. One durable snapshot.
Exact vector, provider-free lexical, and deterministic hybrid retrieval now share the same local authority, bounded failure model, and offline-verifiable evidence.
Q15 cosine
Durable named vector spaces use caller-supplied signed-Q15 vectors. Ranking is exact, bounded, and stable by binary key.
score desc → key ascBM25F-compatible
Pinned Unicode normalization and deterministic integer scoring provide lexical retrieval without an embedding or model provider.
provider-free → rebuildableDeterministic hybrid
Complete lexical and vector branches fuse with fixed integer RRF, explicit weights, stable ties, and per-modality explanations.
RRF k=60 → explainedrequestrankexplainproveverify offline
Read the retrieval semanticsMany applications inherit a database service, cache, network policy, credentials, observability stack, and failure domain before they have proven they need any of them.
Hyphae was created for the opposite starting point: keep durable authority beside the application, expose exact limits, and make results answerable to evidence.
- No mandatory Postgres, Redis, Valkey, or cloud account.
- No AI dependency for KV or structured query.
- No partial result disguised as success.
The proof journey
One answer. Five accountable transitions.
Scroll through the path from an accepted mutation to a result that can be challenged outside the serving process.
The mutation becomes durable authority.
A caller-visible UUID makes the write safe to retry. The checksummed, digest-chained log owns the fact—not an index or cache.
mutation_id / durableThe same state returns after interruption.
Startup scans the authoritative log, rejects corrupt tails, and rebuilds accelerators without letting them redefine truth.
log_head / recoveredOne logical snapshot answers completely.
Filters, global ordering, cursors, and aggregations execute under explicit budgets. A limit failure abstains instead of returning a partial success.
snapshot / generation-42The result leaves with its evidence.
The request, complete result, snapshot witness, semantics version, and caller-selected durable anchor bind into portable proof material.
result.hyproof / portableTrust can move away from the server.
A separate verifier reexecutes the result against the supplied witness and pinned anchor—without the original process, network, database, or model.
reexecution / exactA concrete example
Ask for records. Receive an answer you can take apart.
This is the difference between a response that merely looks plausible and a result tied to an exact query, snapshot, and anchor.
Which edge records scored above 80?
hyphae query \
--field group --equals '"edge"' \
--sort score --proof-out result.hyproof- delta97
- alpha91
- complete
- true
- snapshot
- generation 42
- proof
- result.hyproof
Reexecute somewhere else.
hyphae verify \
--proof result.hyproof \
--snapshot witness.snapshot \
--anchor sha256:<expected-anchor>Verifiable by result
The answer ships with a way to challenge it.
A successful read can name the snapshot and anchor needed to verify the result somewhere else, later, without trusting the serving process.
- 01Query
Execute against one logical snapshot.
- 02Witness
Bind the complete snapshot evidence.
- 03Anchor
Pin the caller-selected durable head.
- 04Reexecute
Verify the proof offline.
querycomplete result
snapshotgeneration 42
anchorcaller-pinned
verifyoffline / exact
Architecture
Durable below. Replaceable above.
The log is authority. Indexes are accelerators. Clients and integrations stay outside the core and speak versioned contracts.
SURFACESEmbedded Rust · Local CLI · /v1 clients · MCP
ENGINEDocuments · Query · Exact / lexical / hybrid retrieval · Proofs
DURABILITYAppend-only log · Snapshots · Rebuildable indexes
OPERATIONSDoctor · Backup · Verify · Restore · Compaction
Where it fits
Use autonomy where autonomy changes the failure model.
Hyphae is most valuable when local custody, bounded behavior, and recovery evidence matter more than a managed service dashboard.
Local-first tools
Ship durable structured data with a desktop app, developer tool, or offline utility.
Map the architecture →Edge and appliance software
Operate without assuming a reachable database or control plane.
Map the architecture →Audit-sensitive workflows
Keep proof-bearing reads and portable recovery evidence near the application.
Map the architecture →Framework data planes
Add Hyphae through public contracts while the host remains fully functional without it.
Map the architecture →No AI required
Structured first. Semantic when you choose.
KV, filters, sorting, cursors, aggregations, recovery, and proofs do not depend on an LLM or embedding model.
KV · query · aggregation · recovery · proof
Exact Q15 · lexical BM25F · hybrid RRF · proofs
Questions
Start with the boundary.
Hyphae is deliberately smaller than a data platform and more accountable than a black box.
Does Hyphae require an external database?
No. The base deployment is one Hyphae binary and one data directory. KV, structured query, recovery, and verification work without Postgres, Redis, a cache, or a cloud service.
Does it require an LLM or embeddings?
No. Structured operations and lexical retrieval work without AI. Exact vector retrieval accepts caller-supplied vectors, and Hyphae never calls an embedding provider.
What makes a result verifiable?
Result and retrieval proofs can be reexecuted offline against a caller-pinned anchor and complete snapshot witness.
Is Hyphae a hosted SaaS?
No. Hosted multitenancy, billing, a control plane, and cloud operations are deliberately outside the autonomous engine.
