Use this as your Show HN post
Option A (direct):
Show HN: SanTOK Cognitive – A reasoning substrate that prevents LLM hallucination
Option B (problem-focused):
Show HN: I built a System-2 layer for LLMs – structured knowledge + symbolic inference
Option C (contrarian):
Show HN: LLMs shouldn't think, only talk. Here's the missing reasoning layer.
I've been working on something different: instead of making LLMs bigger or prompting them better, I built a separate reasoning layer that sits underneath them.
**The core idea:** LLMs are great at generating fluent text, but unreliable at reasoning. So I separated the two:
- SanTOK Cognitive does the thinking (symbolic, deterministic, explainable)
- The LLM just verbalizes the result (fluent, natural)
**What it does:**
- Knowledge graph with 15 relation types (IS_A, PART_OF, CAUSES, etc.)
- 20+ inference rules (transitivity, inheritance, symmetry)
- Constraint enforcement (LLM can only use verified facts)
- Full reasoning traces (every answer shows its work)
**What it doesn't do:**
- No neural networks
- No training
- No external dependencies (pure Python stdlib)
- No hallucination (by construction, not mitigation)
**Example:**
```python
from santok_cognitive import UnifiedMemory, SanTOKReasoner
memory = UnifiedMemory()
memory.add("Python is a programming language", "fact")
memory.add("Programming languages are tools", "fact")
reasoner = SanTOKReasoner(memory)
answer = reasoner.ask("What is Python?")
print(answer.text) # "Python is a type of programming language."
print(answer.explain()) # Full reasoning trace
Why I built this:
Everyone's focused on scaling LLMs. But hallucination, explainability, and consistency remain unsolved at the model level. I think the answer isn't a bigger model—it's a smarter architecture.
SanTOK Cognitive is System-2 for AI: slow, deliberate, correct. The LLM is System-1: fast, intuitive, fluent. Together, they're more reliable than either alone.
Technical details:
- 35 Python modules
- 32 formal invariants (provable properties)
- 6 custom algorithms
- Full documentation
Target use cases:
- Regulated industries (healthcare, finance, legal)
- Enterprise knowledge systems
- AI safety / alignment research
- Anyone who needs AI they can audit
GitHub: [link] Docs: [link]
Happy to answer questions about the architecture, design decisions, or use cases.
---
## Anticipated HN Questions & Answers
### Q: "How is this different from RAG?"
> RAG retrieves documents. SanTOK retrieves structured knowledge AND applies inference rules. RAG can still hallucinate because it just pastes text into a prompt. SanTOK enforces constraints: the LLM can only use facts that exist in the knowledge graph.
### Q: "This sounds like expert systems from the 80s"
> Fair comparison. The key differences: (1) modern graph + tree structures instead of flat rules, (2) inference is bounded and terminates provably, (3) we separate reasoning from verbalization—the LLM handles natural language, not the symbolic system. We learned from why expert systems failed.
### Q: "Does this actually work at scale?"
> Current implementation is optimized for correctness, not scale. Works well up to ~100K nodes. Performance optimization is on the roadmap, but the architecture doesn't have fundamental scaling limits—it's graph traversal and rule application, both well-understood.
### Q: "Why not just fine-tune the LLM?"
> Fine-tuning doesn't solve hallucination—it just changes what the model hallucinates about. SanTOK prevents hallucination by construction: the LLM literally cannot output facts that aren't in the knowledge graph. That's a fundamentally different approach.
### Q: "What's the business model?"
> Open source core, potentially enterprise features later (advanced inference, scaling, hosted version). Right now focused on building something correct and useful. If it works, monetization follows.
### Q: "Why no dependencies?"
> Intentional. Dependencies introduce: (1) security risks, (2) version conflicts, (3) deployment complexity. Pure stdlib means it runs anywhere Python runs. For a reasoning substrate that might be used in regulated environments, this matters.
---
## Reddit Post (r/MachineLearning, r/LocalLLaMA)
**Title:**
> [P] SanTOK Cognitive: A symbolic reasoning substrate for LLM-based systems (no neural networks, no dependencies)
**Body:**
Same as HN post, but add:
> **Paper-like framing:** This is essentially implementing "cognitive substrates for grounded AI"—the idea that LLMs need a separate reasoning layer rather than trying to do everything in one neural network. The architecture separates reasoning (symbolic, deterministic) from verbalization (neural, fluent).
> **For researchers:** We specify 32 formal invariants including inference termination, bounded confidence, and taxonomic acyclicity. The system is designed to be provably correct, not just empirically good.
---
## Twitter/X Thread
**Tweet 1:**
> I built a "System 2" for LLMs.
>
> Not a plugin. Not a prompt trick. A separate reasoning layer.
>
> It does the thinking. The LLM just talks.
>
> 🧵 Thread on why this matters and how it works:
**Tweet 2:**
> The problem: LLMs hallucinate, can't explain themselves, and give different answers each time.
>
> The usual fix: Better prompts, more data, bigger models.
>
> My fix: Don't let the LLM think at all. Give it the answer and let it verbalize.
**Tweet 3:**
> SanTOK Cognitive is a knowledge graph + inference engine + constraint system.
>
> - 15 relation types
> - 20+ inference rules
> - Full reasoning traces
> - Zero hallucination (by construction)
>
> The LLM receives structured facts + hard constraints. It can only verbalize what's true.
**Tweet 4:**
> This isn't new philosophy. It's old AI (symbolic reasoning) + new AI (neural verbalization).
>
> Expert systems failed because they couldn't talk naturally.
> LLMs fail because they can't reason reliably.
>
> Combine them correctly and you get the best of both.
**Tweet 5:**
> Use cases:
> - Regulated industries (healthcare, finance, legal)
> - Enterprise knowledge systems
> - AI safety research
> - Anywhere you need auditable AI
>
> Open source. Pure Python. No dependencies.
>
> GitHub: [link]
---
## Launch Checklist
Before posting:
- [ ] GitHub repo is public
- [ ] README is complete
- [ ] All demos run without errors
- [ ] LICENSE file exists
- [ ] No sensitive info in code/docs
- [ ] Contact info in README (optional)
After posting:
- [ ] Monitor HN for 2-3 hours
- [ ] Respond to comments promptly
- [ ] Be humble, not defensive
- [ ] Thank people for feedback
- [ ] Note suggestions for future work
---
## Timing Tips
**Best HN posting times:**
- Tuesday-Thursday
- 9-11 AM EST (6-8 AM PST)
- Avoid weekends, holidays
**First hour is critical:**
- Get 3-5 upvotes quickly (ask friends if needed)
- Respond to every early comment
- Keep answers concise and technical
---
Good luck! 🚀