False-Belief Check¶
Diagnostic check — instantiates Other-Agent State Model Calibration
Tests the single assumption that the other agent knows what you know — catching curse-of-knowledge errors before they distort an explanation, interface, or instruction.
False-Belief Check is the archetype's narrowest instrument: it isolates one high-frequency error and tests only for that. The error is the actor unconsciously importing their own knowledge into the other agent's head — assuming the recipient knows a term, a context, or a prior step that only the actor actually holds (or, less often, assuming ignorance of something the other agent knows perfectly well). Where a full map models the whole mind and a red team attacks motives, this check does one thing: it separates what the actor knows from what the other agent could plausibly know, and flags every place the message silently assumes they're the same. Its defining trait is deliberate narrowness — a cheap, repeatable probe aimed at the most common failure in teaching, documentation, and expert communication.
Example¶
A senior engineer writes onboarding docs for a new payments API and runs a False-Belief Check before publishing. She lists what the first paragraph assumes the reader already knows: that "idempotency key" is a familiar concept; that the sandbox environment must be enabled in account settings; that "the usual retry semantics" refers to the company's internal convention. For each, she asks the decisive question — how would a brand-new integrator have come to know this?
Two items have no plausible acquisition path. A new external developer has never seen the internal retry convention and may not know idempotency keys at all. Those two are the false-belief traps: knowledge the author has and unconsciously assumed the reader shares. The fix is small — a one-line definition and a link to enabling the sandbox — but without the check they would have shipped as invisible cliffs that make a competent reader feel lost. The check found them not by improving the docs' content but by testing a single assumption about the reader's knowledge.
How it works¶
- Enumerate the assumed knowledge. List what the message takes for granted that the recipient already knows, can infer, or has done.
- Trace an acquisition path. For each item, ask how this recipient would plausibly have come to know it; items with no path are candidate false-belief traps.
- Run the reverse check. Also flag where the actor assumes the recipient is ignorant of something they in fact know — the condescension error.
- Flag, don't rewrite. The check outputs a list of asymmetric-knowledge points; fixing them is a separate step, done by whoever owns the message.
Tuning parameters¶
- Enumeration scope — terms only, or terms plus concepts, prior steps, and unstated context. Wider scope catches more but costs time on low-risk material.
- Acquisition-path strictness — how plausible a route to the knowledge must be before an item passes. Strict tracing catches subtle gaps; loose tracing waves through cliffs.
- Reverse-check toggle — whether to also test for assumed ignorance. Worth turning on with expert audiences, where over-explaining is the bigger risk.
- Recipient profile — which reader the check runs against — a true novice, a lateral expert, a returning user. The same message passes for one and fails for another.
When it helps, and when it misleads¶
Its strength is leverage for almost no cost: a five-minute pass catches the single most common expert-communication failure, and it does so without needing access to the actual recipient. It turns the vague worry "am I explaining this right?" into a concrete list of assumed-shared knowledge to verify.
Its failure mode is that it is only as good as the enumeration — it tests the assumptions you notice, and the most dangerous curse-of-knowledge gaps are the ones so ingrained the author can't see them to list. Its misuse is inverting into condescension, "checking" by over-explaining everything to everyone until competent readers are insulted. It targets the curse of knowledge directly — the difficulty of un-knowing what you already know.[1] The discipline that keeps it honest is to confirm the fix against a real recipient (a genuine novice reading it cold), because a passed check narrows the risk but never proves the knowledge is actually shared.
How it implements the components¶
actor_state_separation— the check is this component made into a procedure: it pulls apart what the actor knows from what the recipient can know, which is the archetype's named defence against curse-of-knowledge errors.hidden_state_hypothesis_set— it operates on the knowledge-and-belief slice of that set, testing specific hypotheses ("does the reader hold concept X? does the reader carry false belief Y?") rather than the whole mind.
It does not build the full model that holds those hypotheses (that's the Belief-Desire-Knowledge Map), challenge the other agent's motives (Counterparty Model Red Team), or govern whether the model is legitimate to hold (Consent and Privacy Boundary Checklist) — it isolates one error and tests for it.
Related¶
- Instantiates: Other-Agent State Model Calibration — the focused knowledge-symmetry test within the archetype's toolkit.
- Sibling mechanisms: Belief-Desire-Knowledge Map · Perspective-Taking Interview · Empathy Map with Evidence Marks · Active Listening Loop · Consent and Privacy Boundary Checklist · Counterparty Model Red Team · Prediction and Surprise Log · Role-Reversal Simulation · Interaction After-Action Review · Stakeholder Hidden-Constraint Board
Editorial Notes¶
Form Classification¶
Form family: Assessment, Review & Assurance
Rationale: False-Belief Check operates as a bounded evaluation of existing evidence or work that produces a finding or disposition because it tests the single assumption that the other agent knows what you know — catching curse-of-knowledge errors before they distort an explanation, interface, or instruction.
Independent corroboration: The frozen evidence defines False-Belief Check as 'Tests the single assumption that the other agent knows what you know — catching curse-of-knowledge errors before they distort an explanation, interface, or instruction', so its operative form is Assessment, Review & Assurance.
Review outcome: Independent reviewer agreement; high confidence.
Origin Attribution¶
Primary origin: Psychology
Origin pattern: Single lineage
Present-day reach: Universal
Rationale: Developmental psychology created the false-belief task to test whether a person can represent another agent's outdated belief rather than substitute their own knowledge.
Related originating lineages:
- Cognitive Science — Mental-state modeling materially generalized false-belief reasoning to interfaces and artificial agents. False-belief tasks and models of another agent's knowledge are canonical cognitive-science tools for theory of mind.
- Human-Computer Interaction — Audience-model and user-knowledge testing materially adapts the check to interfaces and instructions.
Review resolution: Wimmer and Perner's 1983 experiment is the original named task. Cognitive science theorized the capacity and HCI later applied it to explanation design; the everyday check is an encyclopedia transfer.
Encyclopedia synthesis: The exact catalogued form synthesizes established practice rather than reproducing a single standard historical label.
Review outcome: Researched adjudication after independent review; high confidence.
Sources consulted:
Notes¶
A passed check is not proof of understanding — it only clears the specific assumptions that were enumerated and tested. Absence of an obvious knowledge gap is weak evidence; real confirmation still comes from the recipient demonstrating the knowledge, not from the check clearing it.
References¶
[1] The curse of knowledge (Camerer, Loewenstein & Weber, 1989) is the difficulty of imagining not knowing something you already know. Its developmental cousin is the false-belief task (Wimmer & Perner, 1983) — later familiar as the Sally–Anne test — which asks whether one can model another agent's outdated belief; the check operationalises the same idea for everyday communication. withdrawn registry ↩