stemedb/future-vision.md

Vision: Epistemic Logits (The Neuro-Symbolic Cortex)

Status: Vision / L9 Roadmap Target: Solves "Intrinsic Hallucination" Core Concept: StemeDB is no longer just a database we query; it is a constraint layer applied to the model's probability distribution during inference.

---

1. The Problem: The "RAG Ceiling"

Current architectures (including our own Aphoria/ADK stack) rely on Retrieval Augmented Generation (RAG). This is a "Glass Box" system, but it is composed of two disconnected brains:

1. The Retriever (StemeDB): Knows what is true, what is conflicted, and who said what.
2. The Generator (LLM): Knows how to predict the next token based on statistical patterns.

In our current architecture, we paste the Truth (1) into the Context Window of the Generator (2) and hope the Generator attends to it.

The Failure Mode: The Generator can still ignore the context. It can hallucinate. It can state a high-conflict fact with absolute certainty ("X is true") instead of qualified uncertainty ("Some sources claim X").

We cannot fix this by prompting. We must fix it by math.

---

2. The Solution: Epistemic Logits

Epistemic Logits is a decoding strategy that modifies the probability distribution of the LLM's output layer in real-time, based on the ConflictScore and TrustRank of the concepts being generated.

We move StemeDB from the Input Layer (Prompt) to the Activation Layer (Logits).

The Core Equation

 P_{final}(token) = P_{model}(token) \times E(Subject, Predicate) 

Where E is the Epistemic Function:

• If ConflictScore > 0.8 (High Disagreement) AND Token implies certainty ("is", "proven", "fact"), then E \to 0 (Penalty).
• If ConflictScore > 0.8 AND Token implies uncertainty ("reported", "alleged", "contested"), then E \to 1 (Boost).
• If SourceTier is Low (Anecdotal) AND Time is old (Decayed), then E \to 0.

Result: The model physically cannot state a contested claim as a fact. It effectively has a "physics engine" for Truth.

---

3. Architecture: The Neuro-Symbolic Stack

[ User Query ]
      │
      ▼
[ 1. Semantic Router ] ───► [ StemeDB (The Graph) ]
      │                          │
      │ (Context)                │ (Constraints & Scores)
      ▼                          ▼
[ 2. LLM Core ]          [ 3. Epistemic Decoder ]
(Transformer)            (Logit Processor)
      │                          │
      └──► [ Raw Logits ] ──────►│
                                 │ ◄── "Don't say 'proven' if Conflict > 0.5"
                                 │
                                 ▼
                         [ Final Token ]

Component 1: The Lookahead Mapper

To constrain logits, we must know what the model is about to say. We implement a lightweight "Concept Probe" (a small BERT model or sparse autoencoder) that runs parallel to the main LLM.

• Input: Current generation stream.
• Output: The StemeDB::SubjectID the stream is discussing.

Component 2: The Constraint Projector

Once the Subject is identified, StemeDB projects the Epistemic State of that subject into a set of forbidden/boosted tokens.

• State: Semaglutide::has_side_effect -> Conflict: High.
• Constraint: Ban absolute assertions. Boost attribution markers ("According to FDA...", "Patients report...").

Component 3: The Reward Loop (RLHF on Reality)

We use the VoteStore not just for consensus, but to train a Reward Model.

• Data: Millions of historical votes where Agents disagreed.
• Training: Fine-tune the LLM to prefer outputs that align with the weighted consensus of the Graph.
• Outcome: The model "intuitively" knows which sources are trustworthy (Tier 0/1) without needing RAG retrieval for every fact.

---

4. Implementation Roadmap (The Path to L9)

Phase 1: Structured Decoding (The "Guardrails")

Integrate StemeDB with grammar-constrained generation libraries (like guidance or outlines).

• Mechanism: Force the LLM to output a citation struct { claim: "...", source_id: "...", confidence: 0.0-1.0 } for every assertion.
• Validation: If the generated source_id does not exist in StemeDB, or if the confidence doesn't match the VoteStore, reject the token stream and regenerate.
• Deliverable: crates/stemedb-guidance: A Rust binding for grammar-constrained sampling backed by the KV store.

Phase 2: DPO Pipeline (The "Training")

Direct Preference Optimization using StemeDB history.

• Mechanism: Export the VoteStore history as (Prompt, Chosen, Rejected) tuples.
  • Chosen: An assertion supported by Tier 0 (Regulatory) sources.
  • Rejected: A conflicting assertion supported only by Tier 5 (Anecdotal) sources.
• Action: Fine-tune a Llama-3 8B model on this dataset.
• Deliverable: crates/stemedb-rlhf: A pipeline that turns WAL segments into HuggingFace datasets.

Phase 3: The Logit Processor (The "Cortex")

Real-time intervention.

• Mechanism: A custom sampler (integrated into llama.cpp or vLLM) that queries StemeDB's MaterializedView in real-time (sub-millisecond) during inference.
• Optimization: This requires the HybridStore to be memory-mapped into the inference engine's address space for zero-latency lookups.
• Deliverable: episteme-inference: A standalone inference server that speaks OpenAI API but enforces StemeDB truth constraints.

---

5. The Impact

When we achieve Epistemic Logits, we solve the Liability Gap.

Currently, no enterprise can deploy an autonomous agent for critical tasks (Medical, Legal, Finance) because they cannot guarantee the output.

With Epistemic Logits, we provide a mathematical guarantee: "This system is incapable of stating a claim with higher confidence than the underlying evidence supports."

This transforms AI from a creative writing tool into a fiduciary instrument.