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. KV, structured query, recovery, and proof-bearing results—offline, without an external database or AI.
Structured query works with no LLM, embeddings, cloud, or external database.
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.
Retry safely
Caller-visible UUIDs make mutation retries durably idempotent across restarts.
Recover deliberately
Snapshots, compaction generations, backups, restore, and doctor expose complete evidence.
Prove the result
Portable result proofs reexecute offline against a pinned anchor and snapshot witness.
Integrate optionally
Rust, HTTP, TypeScript, Python, CLI, MCP, and framework adapters consume public contracts.
Many 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 · Retrieval · Result 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
Provider-neutral vectors · explicit abstention
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 work without AI. Semantic retrieval is optional, exact, and provider-neutral when a Rust host supplies vectors.
What makes a result verifiable?
Proof-bearing reads 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.
