Engineered for cognition
A purpose-built engine designed around memory, state, and context — not adapted from traditional database architectures.
How Durbl is structured
Durbl is organized in layers, each with a specific responsibility. Data flows from the SDK through the engine's processing pipeline, into the storage layer, and back out through the context runtime.
SDK & API Layer
Your application communicates with Durbl through our typed SDKs (Python, TypeScript) or raw REST API calls.
Processing Engine
The cognitive runtime handling data flow, intelligence, and lifecycle events natively without external dependencies.
Write Pipeline
Classifies, scores, and connects incoming cognitive data
Context Runtime
Assembles goal-aware context frames from raw memory
Lifecycle Engine
Reinforces, decays, drops, and manages memory health
Intelligence Kernel
Discovers hidden patterns natively, detects anomalies automatically, and strictly monitors overall systemic memory health.
Storage Layer
Purpose-built, temporal storage with semantic search indexing embedded, relationship tracking, and lifecycle journaling.
Write Pipeline
Every piece of data flows through a multi-step processing pipeline before it becomes memory.
Validate
Incoming data is cleaned, validated, and structured into a consistent format.
Classify
The engine determines what type of memory this is: episodic, semantic, preference, procedural, or task-related.
Score
Each memory receives scores for importance, confidence, and durability — determining how long it persists and how easily it's recalled.
Represent
Content is converted into a semantic representation for intelligent retrieval.
Route
Based on scores and type, the memory is directed to the appropriate storage tier.
Connect
The engine discovers and creates relationships to related memories, entities, and states.
Signal
If the new data triggers any patterns, anomalies, or state changes, signals are emitted.
Context Runtime
Context is computed, not fetched.
When your application requests context for a specific goal, the runtime executes a multi-step assembly process to deliver the most relevant, diverse, and policy-compliant context.
Gather
Candidate memories are gathered using semantic similarity, entity scope, and temporal relevance.
Rank
Each candidate is scored by relevance to the stated goal, combined with its importance and recency.
Diversify
The engine ensures variety across memory types — avoiding redundant context.
Assemble
The final context frame is structured and optimized for consumption by language models or application logic.
Lifecycle Engine
Memory that maintains itself.
Without active lifecycle management, AI memory becomes noisy, outdated, and expensive. Durbl continuously maintains memory health.
Reinforce
Accessed or confirmed memories become stronger and more durable.
Decay
Unused memories gradually lose priority over time.
Merge
Similar memories are intelligently combined.
Summarize
Large volumes of episodic memory are condensed while preserving key information.
Archive
Valuable but inactive memories move to efficient long-term storage.
Forget
Memories below minimum thresholds are permanently and intentionally removed.
Intelligence Kernel
Discovering meaning across time.
The engine continuously monitors all data flows, identifying significant events without prompts. It surfaces 4 core signal types to your application.
Patterns
Repeated behaviors, consistent preferences, or cyclical events discovered over time.
Anomalies
Events that significantly deviate from an entity's established baseline or past behavior.
Milestones
Major state thresholds, goal achievements, or lifecycle events.
Conflicts
Contradictions between new cognitive events and firmly held historical memory.
The 6 Primitives
Durbl's data model is built on 6 cognitive primitives.
MemoryObject
The atomic unit of memory. Carries content, semantic embeddings, quality scores, and lifecycle metadata.
StateObject
Versioned snapshots of entity state. Immutable history with temporal queries.
ContextFrame
Assembled context for a specific goal. The bridge between memory and reasoning.
MemoryLink
Typed relationships between memories. Enables knowledge graph traversal.
CognitiveEvent
Raw input events that flow through the write pipeline.
PolicyObject
Governance rules for retention, decay, access control, and compliance.
Design Principles
Durbl owns its data model, processing pipeline, and storage layout. It is not a wrapper over existing databases.
Memory is not an afterthought or a feature. It is the core primitive.
Temporal ordering, change tracking, and historical queries are built into the foundation.
Data without lifecycle management becomes noise. Durbl maintains memory health automatically.
The engine observes, discovers, and signals — it doesn't just store.
Performance
Durbl is engineered for low-latency, high-throughput AI workloads.
| Operation | Target Latency |
|---|---|
| Memory write | < 1ms |
| Semantic recall | < 5ms |
| Context assembly | < 15ms |
| State read | < 0.1ms |
* These are engineering targets for V1. Actual performance depends on deployment configuration and workload.