Crash→Lost state→Replay guessing→Corruption
Process dies during transition. No durable checkpoint. Restart must guess what to do next.
The durable state substrate
The durable state substrate for software that acts.
Applications. Agents. Workflows. Devices. Everything that runs needs to remember what it did. FeltDB is the durable state engine built into your application—atomic transitions, causal consistency, automatic recovery, and deterministic execution, built in.
Free to start. No credit card.
app.ts
// FeltDB is application state
const todos = db.collection('todos');
await todos.insert({
title: 'Ship the product',
done: false
});
todos.subscribe(render);● Persisted locally · syncing live
Durable StateAtomically written, never partial
Atomic TransitionsAll-or-nothing state changes
Causal ContextOperations respect cause and effect
Durable AuthorityResults decided once, enforced forever
Built for failure
Real software fails. FeltDB expects it.
Process crashes, network partitions, concurrent access, concurrent recoveries, and corrupt historical state are not edge cases—they're engineering reality. FeltDB guarantees: durable operation identity, atomic governance, convergence across restarts, and audited recovery from corruption.
Process dies at any pointDurable operation stateRestart knows exactly what happened
Crash at any boundary: before transition, during transition, after transition. Every state is queryable. Recovery is deterministic.
Core guarantees
The four pillars of production-ready state.
FeltDB isn't just faster storage. It's the foundation that makes "software that acts" actually reliable. Durable identity prevents duplicate execution. Atomic governance prevents corruption. Automatic recovery prevents data loss. Deterministic execution prevents ambiguity.
Durable identity
Every action gets a persistent ID that survives process crashes and network failures. Admit work once; know it will never be admitted twice.
Atomic governance
State transitions that cannot go halfway. Version numbers prevent staleness. Concurrent writers see VERSION_CONFLICT and retry intelligently.
Deterministic recovery
Restart and know exactly where you left off. No guessing. No replay of completed work. Full operation history is durable and queryable.
Durable authority
Results are decided once and enforced forever. Terminal operations cannot be rewritten. Authority is not delegated—it is decided once and persisted immutably.
Built for systems that act
One substrate for applications, agents, control planes, and distributed systems.
When state is durable, atomic, causal, and recoverable, systems that once required complex coordination frameworks become reliable and simple.
Applications that make decisions
Admit work, transition it through a lifecycle, complete it. If your process dies mid-transition, know the exact state on restart. Never re-execute admitted work.
Work admission · transitions · durable resultsAgentic systems
Agents need trustworthy state. Track each action atomically. Query operation history and know what already executed. No hallucinating. No phantom executions.
Action tracking · durable history · recoveryOperational control planes
Coordinate work across fleets. Assign tasks, track progress, enforce SLOs. Ensure restarts never reissue commands or lose pending state.
Task transitions · auditability · orchestrationDistributed systems
Multiple components need consistent authority. Atomic transitions with version-based conflict detection. Multi-process restart converges to identical state.
Convergence · conflict detection · synchronizationWorkflow engines
Long-running workflows need durable checkpoints. FeltDB tracks which steps executed, which are pending, and preserves context across restarts.
Step tracking · checkpoints · resumptionEvent-driven systems
Build causally-ordered event systems where operations respect cause-and-effect. No out-of-order execution. No lost events.
Causality · ordering · durabilityNot another backend API
FeltDB lives in your process, not on a remote server.
No network latency. No hidden retries. No server-side magic. You control your state directly, and FeltDB ensures it's durable, consistent, and recoverable. Sync and replication are optional—not required.
Before
// Traditional application data
const response = await fetch('/api/todos');
const todos = await response.json();
await fetch('/api/todos', {
method: 'POST',
body: JSON.stringify(todo)
});With FeltDB
// FeltDB is application state
const todos = db.collection('todos');
await todos.insert({
title: 'Ship the product',
done: false
});
todos.subscribe(render);
The substrate is complete. Build on solid ground.
Durable identity, atomic transitions, causal ordering, and automatic recovery. FeltDB gives your application the foundation for systems that act, decide, and recover reliably.
Start building →