KNOT — an experimental reasoning architecture that argues with itself (first prototype showcase)

Meet the knot. I spent a month making him argue with himself.

This is KNOT, and this is its first public prototype showcase — one month of building, breaking, and rebuilding, and it's finally at a place worth writing up properly.

KNOT isn't a chatbot. It's an experiment in making reasoning itself inspectable — a system built to examine how a claim is reasoned about, not just what conclusion comes out the other end.

Why

Most LLM tooling optimizes for a good final answer. KNOT does the opposite on purpose: it slows down, surfaces the assumptions a claim depends on, runs adversarial agents against each other, and refuses to collapse a genuine contradiction into a fake resolution just because a fake resolution sounds cleaner.

The clearest way to show that wasn't a diagram — it was to point KNOT at itself and let it run.

What's actually in the carousel below
This isn't a UI mockup and nothing here is fabricated for effect. Every slide is reconstructed from an actual reasoning trace, produced by running KNOT against one of its own design principles: should a system built to interrogate contradiction be trusted to interrogate itself?
The visuals are mine. The reasoning traces are KNOT's.

Architecture

The current prototype stitches together local LLM inference, semantic retrieval, contradiction detection, rule-based reasoning, and persistent reasoning artifacts into a single pipeline.

Stack:

• Backend: FastAPI + Python
• Inference: Ollama-hosted local LLMs (no external API calls in the reasoning loop)
• Semantic similarity: Sentence-Transformers
• Contradiction detection: DeBERTa-v3 NLI
• Reasoning control flow: rule-based routing between reasoning stages
• Persistence layer: reasoning artifacts I call "Paradox Seeds" — atomic, storable units of a reasoning episode, not just the final output
• Evaluation: structured pipeline for benchmarking and regression testing, still being hardened

Reasoning pipeline, roughly:

1. Shadow Recovery — reconstructs the suppressed claim, cost, or consequence the original framing depends on leaving unspoken
2. Fight Club — two adversarial agents (Axiom, a structural adversary that attacks hidden assumptions and false equivalences; Virtus, a human-cost witness that tracks who gets made invisible when an argument becomes efficient) argue directly, including rebuttals, not parallel monologues
3. Forge — compresses the two positions until the unresolved core becomes impossible to evade, rather than averaging them into a bland synthesis
4. DoubleSpace — holds two genuinely incompatible truths active at once, without subordinating either
5. Belief Autopsy — compares the system's initial claim against what examination exposed, and names the defense mechanism the original claim was using to protect itself
6. Archive — the case, including everything unresolved, gets persisted as a lineage artifact instead of discarded once an answer is reached

What I actually learned pointing it at itself
The most useful output wasn't a clean answer. It was this line, which KNOT produced when I asked it whether a system that remembers your contradictions should be trusted to also judge them:

"The danger isn't that KNOT remembers. The danger is that remembering can become judging."

That's the kind of finding that's hard to get a model to produce honestly when it's being asked to evaluate itself — the easy failure mode is a system that either praises its own design or performs fake self-criticism. Getting Belief Autopsy to actually name a real defense mechanism, rather than a token concession, took several iterations of prompt and pipeline design.

Where it actually is right now

Being straight about this: KNOT is an early research prototype, not a finished product.
Built and being stress-tested:

• Contradiction detection and Shadow Recovery
• Adversarial synthesis (Fight Club, Forge, DoubleSpace)
• Belief Autopsy
• Persistent reasoning artifacts (Paradox Seeds)

Still on the drawing board:

• Longitudinal memory across sessions
• Identity drift detection over time
• Temporal/future-projection reasoning modules

Not released. Not open source — yet. I'm validating the core reasoning architecture properly before I think seriously about public access, rather than shipping something half-proven because a launch feels good.

If you're working in this space

I'd genuinely like to compare notes with anyone working on reasoning systems, LLM evaluation, contradiction/consistency detection, or cognitive architectures more broadly. Happy to go deeper on any part of the pipeline in the comments — including the parts that didn't work on the first few tries.