FaultLine is a self-correcting memory system for LLM applications.
Most AI memory systems degrade over time — accumulating stale, incorrect, and conflicting information.
FaultLine does the opposite.
It enforces a controlled write path, builds structured knowledge from interaction, and continuously converges toward higher-quality memory through validation, reinforcement, correction, and decay.
LLM memory systems fail in production for predictable reasons:
- They trust the model to write correct data
- They store everything without validation
- They accumulate stale or contradictory facts
- They have no mechanism for correction or decay
Over time, this leads to:
- retrieval noise
- conflicting context
- degraded agent performance
FaultLine solves this by treating the LLM as an untrusted writer.
Memory is not stored by default — it is evaluated, structured, and earned.
FaultLine transforms raw interaction into structured, governed memory:
- Extracts entities and relationships from conversations
- Infers missing structure (hierarchies, causality, relationships)
- Validates all writes against a dynamic ontology
- Builds a continuously evolving knowledge graph
- Promotes high-confidence knowledge to long-term memory
- Removes unused or unreinforced knowledge automatically
- Allows real-time correction of facts and structure
No information is persisted without passing a validation gate.
Facts move through a lifecycle:
- Class C — Candidate (ephemeral, low confidence)
- Class B — Confirmed (reinforced through interaction)
- Class A — Canonical (user-confirmed truth)
Frequently referenced knowledge strengthens and persists.
Unused or unreinforced knowledge expires automatically.
FaultLine builds missing relationships:
- hierarchy (family → members → pets → animals)
- causality
- relational links
Users can modify the graph through natural interaction:
"my name isn’t Todd, it’s Bradly"
"my pets are not part of my family"
FaultLine updates:
- facts
- relationships
- graph structure
All changes are non-destructive and auditable.
| Traditional Systems | FaultLine |
|---|---|
| Trust model output blindly | Treat model as untrusted writer |
| Store everything | Validate before persistence |
| Accumulate noise over time | Decay unused knowledge |
| Static or no schema | Self-evolving ontology |
| Hard to correct | Interactive correction |
| Requires cleanup | Self-maintaining |
Agent Runtime (OpenWebUI / LangChain / etc.)
↓
FaultLine (extract → validate → infer → promote → decay)
↓
PostgreSQL (graph) + Qdrant (semantic)
FaultLine sits beneath your application.
- Your agent writes → FaultLine decides what becomes memory
- Your agent reads → FaultLine returns structured knowledge
FaultLine uses multi-path retrieval:
- Graph traversal (relationships, hierarchy)
- Semantic similarity (Qdrant)
- Confidence-weighted facts (A/B/C classes)
This ensures:
- weak signals remain visible
- strong knowledge dominates
- incorrect structure can be corrected through use
Inference alone is not enough — knowledge must be used and reinforced.
Facts, relationships, and structure must be correctable through interaction.
Unverified or unused knowledge should not persist indefinitely.
FaultLine is not:
- a vector database
- a RAG system
- an agent framework
It is:
→ a governed memory layer that ensures long-term memory remains usable
Use it with:
- OpenWebUI
- LangChain
- custom agents
git clone https://github.com/your-org/FaultLine.git
cd FaultLine
cp .env.example .env
# edit .env
docker compose up -d- Core architecture implemented ✅
- Self-correcting lifecycle ✅
- Dynamic ontology ✅
- Production-scale validation → in progress
Licensed under the MIT License — see LICENSE