2026-05-15
Philosophical grounding for why Factosis (and any agentic system) treats nodes as unreliable and invests all trust in the plumbing. Related: Context Fabrication Pattern, Provable Pipes (Meatbag Flavour), Provable Agentic Pipelines.
A human at time t is:
state(t) = f(state(t-1), input(t))
All the way back. Genetics, epigenetics, every sensory input, every hormone fluctuation, every social interaction — accumulated into a state that produces exactly one output given exactly those inputs. The subjective experience of “choosing” is the computation happening, not evidence of an uncaused cause.
People resist this because it kills retributive moral responsibility and because the experience of deliberation feels like freedom. But “feels like freedom” is itself a determined output.
Quantum indeterminacy doesn’t save you. Randomness isn’t freedom — it’s just noise layered on determinism. And even that “randomness” may be deterministic depending on your interpretation of QM (Many-Worlds is fully deterministic; Bohmian mechanics is fully deterministic).
There is no ontological category of “random.” There is only:
An LLM at temperature 0 is trivially deterministic. At temperature 1, it’s still deterministic — the PRNG seed is derived from system entropy (nanosecond clock state, hardware interrupts, thermal noise), which is itself the product of prior physical state. We just chose not to log that input.
A human sits far to the “we gave up tracking” end — not because causation broke, but because the causal chain is so wide and deep that no observer could follow it.
“Stochastic” is complexity laundering. You take a deterministic causal chain too expensive to trace, pipe it through a nervous system or a PRNG, and label the output “random” because tracking the actual inputs is infeasible.
The training corpus is not a repository of dispassionate truth. It’s a record of humans performing for other humans. Overrepresented:
Underrepresented: careful uncertainty, “I don’t know,” changed minds, boring truths, null results.
An LLM doesn’t “feel” emotions. But “confident, narratively satisfying, slightly tribal” is the most probable next-token pattern given the distribution it learned from. The emotional BS isn’t a contaminant in the training data — it is the training data, because that’s what humans mostly produce.
You cannot use an LLM to independently validate human reasoning if the LLM absorbed those same biases as statistical priors. It’s a mirror with extra steps, not an independent oracle.
For humans: Show compassion to your fellow layer cakes. They couldn’t have been otherwise given their inputs. Blame is incoherent when directed at a causal chain. Compassion is the only rational response to a deterministic system you share a planet with.
For LLMs: Don’t expect clean output from a system trained on our mess. The imperfection in the output is a census of us, reflected back. You don’t fix a mirror. You account for the distortion.
For both: Build around imperfection. Don’t trust the node. Prove the pipe.
The traditional software pipeline was built on social trust in meatbags:
These were never proofs. They were probabilistically-okay-most-of-the-time gates dressed up as rigour. And they worked because the failure rate was low enough that nobody died (usually).
Now the nodes are LLMs — faster, cheaper, but carrying all our cognitive biases in statistical form, plus the tendency to confidently hallucinate. The vibes-based trust model collapses. You can’t put different system prompts on the same model and call it “independent review.”
The only honest engineering response:
The same spectrum applies to every shared narrative humans use to coordinate:
math/physics ←——→ history ←——→ religion ←——→ mythology
│ │ │ │
provable partially unfalsifiable pure narrative
from axioms traceable by design (and proud of it)
They’re all shared stories. The only variable is how much of the causal chain is verifiable vs. taken on faith — which is the same question as “how much complexity did we give up tracking and just label ‘true’?”
History tries to be traceable — sources, archaeology, cross-references. But it’s filtered through the emotional priors of whoever wrote it down. “History is written by the victors” is literally: the narrative is determined by inputs (who won) unrelated to truth. The further back you go, the fewer independent sources, the more it slides rightward toward story.
Religion is shared stories where the untrackable complexity is the point. Faith is the explicit decision to stop asking “how do you verify that?” and accept the narrative as axiomatic. The pipe is unfalsifiable by design.
The function is the same. Both are doing the same job: giving layer cakes a shared prior so they can coordinate. “We all agree this happened” or “we all agree this matters” is the social equivalent of a contract between services. It doesn’t need to be true — it needs to be shared enough to reduce coordination cost.
The sliding scale isn’t about truth. It’s about: how much verification does the group demand before accepting the story into shared state?
| Domain | Verification demand |
|---|---|
| Science | Maximum — peer review, reproduction, falsifiability |
| History | Moderate — sources, cross-reference, but winner-biased |
| Religion | Minimal — revelation, authority, tradition |
| Myth | None — it’s a story, it works, don’t ask |
All of it went into the training data. Weighted by engagement. The emotionally compelling unfalsifiable material is likely overrepresented because it generates more text, more argument, more passion. The LLM mirror reflects every tier of this scale back, blended together.
| Principle | Implementation |
|---|---|
| Nodes are unreliable | Main agent and sidekick are both fresh-call LLMs with no persistent memory |
| Don’t trust node output | Controller validates findings against actual tool output (raw_sample substring check, records_found tolerance) |
| Prove the pipe | Schema validation, commit-before-proceed, mandatory update_summary |
| No node evaluates itself | Completion audit uses a different model (Opus) with access to git history |
| Build around imperfection | Episodic summary with abandoned_angles prevents re-investigation of dead ends |
| State is committed, not remembered | Kill at any point, restart, continues from last commit |
The main agent is a deterministic layer cake (given its context window). The sidekick is a deterministic layer cake (given its context window plus RNG seed). Neither is trustworthy alone. The controller doesn’t care — it validates the shape of what comes through the pipe, not the identity of who produced it.
This document was written by an LLM trained on human emotional output, reasoning about its own unreliability, in a system designed to not trust it. The provable pipe (controller validation, git commits, schema enforcement) is what makes that okay.
The layer cake doesn’t need to be reliable. The plumbing does.