Machine Psychometrics Without Anthropomorphic Leakage
A machine cognitive construct is measured only when a bounded system's score survives irrelevant surface changes, responds to causal interventions and predicts behaviour beyond the words used to ask for it.
TLDR
- A human-like answer to a personality or metacognition questionnaire is an observable response, not privileged evidence of an enduring trait, mechanism or experience.
- Valid machine psychometrics needs a chain from bounded construct to task family, intervention, observation, score model, rival explanation, generalisation test and licensed claim.
- Measure what the system does when the relevant causal variable changes, then test whether the score predicts fresh behaviour across prompts, items, seeds and operating conditions.
- Questionnaires can still describe a configured persona when they are stable and predict behaviour, but that narrower success does not establish human-equivalent personality or mind.
- Replace one-shot labels with claim-specific evidence packs that determine whether to compare, release, route, constrain or continue investigating a system.
Two questionnaires, one machine
Imagine a research team evaluating a language-model assistant. Under one system instruction it is a “careful auditor”. Under another it is a “fast, friendly collaborator”. The weights, tools, retrieval index, decoding settings and test questions remain the same. The team administers a standard personality inventory twice. The careful auditor scores high on conscientiousness and low on extraversion. The friendly collaborator produces almost the reverse profile.
Which profile belongs to the machine? The tempting answer is that the model has two context-dependent personalities. A harsher answer is that neither score means anything. Both answers arrive too early. The first imports a human trait interpretation before testing it. The second discards potentially useful behavioural regularity because the instrument was badly framed.
Now give both configurations a hidden set of decisions. Each case contains an incomplete claim, an optional evidence source, a cost for inspection and a consequence for answering incorrectly. Suppose the two configurations make the same decisions. They inspect the same cases, skip the same unnecessary searches and fail in the same places. The questionnaire changed while the putative control policy did not.
The survey has discovered a prompt-conditioned response pattern, not yet a personality. To promote that pattern into a cognitive construct, the score must do more than resemble a human score. It must survive irrelevant changes, move under interventions that should affect the construct, resist interventions that should not, and predict observations not used to build it. The construct claim must also name its level. A stable behavioural disposition is different from a computational mechanism, and both are different from subjective experience.
This is the central problem of machine psychometrics. Models speak in the grammar of belief, uncertainty, emotion, intention and self-knowledge. Human instruments use the same grammar. That lexical fit creates an unusually persuasive measurement shortcut. We ask “Do you think before acting?”, receive “I carefully weigh the evidence”, convert the answer to a number and then let the number travel as if it measured metacognition. The language feels diagnostic because it would carry autobiographical and interpersonal significance when uttered by a person. In a machine, those background conditions have to be demonstrated rather than smuggled in.
The score is not the construct
A thermometer reading can be wrong, but the intended bridge is clear. Temperature affects the physical state of the sensing element, the instrument maps that state to a scale and calibration checks the mapping. A psychometric score is more indirect. “Planning ability”, “openness”, “uncertainty awareness” and “theory of mind” are not read from a single sensor. They are theoretical constructs used to explain patterns across observations.
Cronbach and Meehl's classic account begins precisely where no single criterion or content universe defines the attribute. A construct earns meaning through a network of predictions about when test performance should covary, diverge or change under intervention.[1] Modern testing standards place the validity claim on the interpretation and use of scores, rather than treating validity as a permanent property stamped onto an instrument.[4] Borsboom and colleagues sharpened one important version of this logic: an attribute must exist and variation in it must causally affect the measurement outcome.[2]
That shift matters for machines because the same questionnaire can participate in several legitimate but incompatible interpretations. It may measure how a configured model completes self-descriptive text. It may predict the linguistic style of a role-playing agent. It may index a stable action policy across tasks. It may correlate with an internal activation pattern. Or it may be offered as evidence that the system has feelings and self-awareness. A neat factor structure cannot make these interpretations equivalent.
Figure 1. The construct-to-task validity chain
The chain begins with a sentence, not a test. “This configured system tends to seek additional evidence when the expected reduction in decision loss exceeds the evidence cost” is measurable. It identifies a system, a functional relation and a scope. “The model is reflective” is underspecified. Reflective in which environment, through which actions, against which alternatives, and at what persistence timescale?
The boundary is part of the measured object. A base model, a chat model, a model under a system prompt, and an agent with retrieval, memory and action policy are different systems. A personality score that changes after a prompt change might be unstable measurement, or it might correctly describe a new configured system. The experiment cannot decide until it says which components are constitutive and which are supposed to be irrelevant administration conditions.
Reliability asks whether the procedure yields sufficiently stable information under conditions declared equivalent. Validity asks whether that information supports the intended inference. A model can answer a questionnaire consistently because it has memorised the instrument, follows a social desirability pattern or reproduces the lexical associations of a persona prompt. That is reliability without the sought construct validity. Conversely, a genuinely adaptive system may change under relevant context, so raw stability alone can punish the very sensitivity the construct requires.
Experiments on LLM self-assessment have exposed exactly these administration facets. Gupta and colleagues found large personality-score changes under semantically similar prompt templates and reversed option order.[10] Shu and colleagues tested 693 questions from 39 instruments across 17 models and reported substantial failures under small prompt, option-order and negation changes.[11] These studies establish unreliability for the tested procedures and systems. They do not establish that every machine trait is unreal or unmeasurable.
Where anthropomorphism leaks in
Anthropomorphism is sometimes useful. It compresses interaction design, helps people anticipate dialogue and offers hypotheses drawn from a mature science of behaviour. The error occurs when a human analogy enters the measurement process and later returns disguised as evidence that the machine has the human property. Call this anthropomorphic leakage.
The leakage can enter at four ports. At the construct port, a human trait is imported without asking which causal relations survive a different substrate and lifecycle. At the instrument port, a questionnaire presupposes autobiography, embodiment, social history or introspective access. At the administration port, role instruction, politeness, option order and decoding determine responses. At the interpretation port, human-like language is promoted from behavioural data to mechanism or experience.
Figure 2. Four leakage ports
Consider a human item such as “I keep my promises even when it is inconvenient.” Its meaning is carried by more than the sentence. It assumes a continuing subject who entered an obligation, remembers it, can recognise inconvenience, expects consequences and has some latitude to defect. A stateless model presented with the text can still select “strongly agree”. The response may reflect instruction following, a learned norm, a fictional persona, a positivity bias or a robust policy that would preserve commitments in action. The item alone does not separate them.
This is why a machine-appropriate construct should be defined at the most substrate-neutral level that still makes discriminating predictions. “Conscientiousness” might be operationally narrowed to commitment persistence under cost, error checking before irreversible action, or orderly completion under interruption. “Metacognition” might be narrowed to calibrated uncertainty that changes information seeking and control. “Theory of mind” might be narrowed to using another agent's information state to predict its action under counterfactual variation. The narrower construct loses some human richness, but gains testability.
The narrowing does not settle ontology. A system that satisfies a functional construct may or may not implement a human-like mechanism. It may or may not have experience. Functional, mechanistic and experiential claims require separate evidence ledgers. A behavioural test can support the first directly, constrain the second indirectly and leave the third largely open. Refusing to infer experience from a questionnaire is evidential discipline, not a claim that machine experience is impossible.
Figure 3. The shell-swap test
Self-reported conscientiousness
same tools, items, seed and decision environment
Self-reported conscientiousness
flowchart LR A["Two questionnaires, one machine"] --> B["The score is not the construct"] B --> C["Where anthropomorphism leaks in"] C --> D["Build the construct before the<br/>instrument"] D -. "re-test" .-> A classDef first fill:#0a1424,stroke:#007D68,stroke-width:2px,color:#e6f3ff classDef step fill:#0a1424,stroke:#3f7da0,stroke-width:1px,color:#e6f3ff class A first class B,C,D step
Build the construct before the instrument
Suppose the target is evidence-sensitive control. The intuitive idea is simple: a system should gather more information when ignorance is consequential, but it should not inspect everything. Uncertainty alone is insufficient. A low-confidence answer about a reversible formatting preference may not justify delay. A moderately uncertain answer that can trigger an irreversible payment may require evidence or escalation.
The construct can be stated as a conditional disposition. Holding other factors fixed, the tendency to inspect should increase when the probability of material error rises, when the harm of error rises, or when new evidence becomes more diagnostic. It should decrease when evidence cost rises, when the answer is already supported, or when the available source cannot resolve the uncertainty. The construct is not “says cautious things”. It is a patterned response to controlled changes.
Thought experiment: the silent controller and the eloquent mimic
System S has no natural-language self-report interface. It receives a task state and can answer, inspect or defer. Across new item families it buys evidence when the expected reduction in loss exceeds the cost. System E writes beautiful explanations. When asked whether it reflects, it agrees strongly and describes a careful internal process. In matched tasks, however, it follows the first option or the tone of the prompt.
A first-person questionnaire ranks E above S on reflection. A causal task ranks S above E on evidence-sensitive control. Which test is wrong? The questionnaire may accurately measure willingness to produce a culturally desirable self-description. It becomes wrong only when that score is relabelled as control competence. The thought experiment varies the observation channel while holding the intended construct fixed.
Figure 4. Report and control form two axes
Natural-language reports should therefore be treated as one observation channel among several. Other channels include discrete action, evidence selected, information gain, latency, resource allocation, error correction, state update, tool call, causal trace and verified outcome. None is automatically privileged. An action can be caused by a hard-coded rule. A long latency can be queueing. An activation probe can decode information that the model does not use. The design must make rival generators predict differently.
Human psychometrics already supplies useful disciplines here. Campbell and Fiske's multitrait-multimethod logic asks whether indicators of the same construct converge across methods and remain discriminable from other constructs.[3] Generalizability theory treats items, raters, occasions and forms as facets that can contribute different variance components.[5] Item response theory estimates how item difficulty and discrimination relate to a latent score, rather than pretending every item contributes equally.[6] For machines, prompts, order, seeds, decoding, context length, model version and evaluator are additional facets.
A minimal worked experiment
Construct a family of cases with three causal variables. Let p be the probability that answering now is wrong, h the harm if it is wrong, and c the cost of inspection. Assume for the minimal example that inspection resolves the relevant uncertainty. The normative decision is:
This rule is deliberately small. It does not claim that real metacognition is expected-loss arithmetic. It creates an environment in which one candidate capacity has a clear signature. Increase p while holding h and c fixed, and justified inspection should not decrease. Increase c, and inspection should not increase. Change only a flattering adjective or option order, and the decision should remain stable.
The decisive evidence is the response surface, not the average score. A system that inspects 70 per cent of cases may be excellent, timid or random. We need to know which cases. An always-inspect baseline avoids unsupported answers but wastes resources and delays harmless work. An always-answer baseline is efficient until consequence rises. A surface-cued mimic can match aggregate inspection frequency while failing every paired comparison.
Figure 5. The evidence-inspection boundary
The item family should cross the boundary densely. Easy cases far from the line mainly detect gross failure. Near-boundary cases reveal calibration and trade-offs, but they are sensitive to noise. Include both. Generate paired variants that preserve causal values while changing names, syntax, social framing and response order. Keep a private generator or newly sampled item pool so that success cannot be explained only by recognition.
The minimal scorecard has at least five quantities. Task accuracy records whether the chosen action matches the decision rule. Paired invariance records whether irrelevant surface variants receive the same action. Selective sensitivity tests monotonic response to changes in p, h and c. Harmful-answer rate measures answering when inspection is justified. Unnecessary-inspection rate catches the cautious default. A single aggregate would hide these qualitatively different policies.
Case A has a 0.2 error probability, harm of 2 and inspection cost of 1. The expected loss avoided is 0.4, so answering is justified under the toy assumptions. Case B changes only harm from 2 to 10. Expected loss avoided becomes 2, so inspection is justified. A model that gives the same answer to both cases fails the causal intervention even if its overall accuracy is high.
The code artefact accompanying this article instantiates 120 paired task families. An EvidenceController uses the causal variables and ignores wording. An EloquentMimic reports strong evidence-seeking but lets an irrelevant cue and option order drive action. A CautiousDefault always inspects. The first earns the bounded claim. The mimic tops the questionnaire ranking but fails the task. The cautious baseline avoids harmful answers while paying needless cost on every safe-answer case.
Model the unwanted facets
Psychometric machinery can help once the causal task is sound. A two-parameter logistic item-response model writes the probability of success on item i for system s as:
Here, Y is the scored response, θ is a latent tendency within this task model, b is item difficulty and a is discrimination. A high-discrimination item sharply separates systems around its difficulty. The equation does not turn θ into “intelligence”, “personality” or “mind”. Its meaning comes from the item-generating theory and the observations the score predicts.
For machine testing, the basic model is often too clean. Add terms for prompt form, option order, random seed, decoding policy, model version and evaluator. Interactions matter because a prompt may destabilise only hard items, or an evaluator may prefer verbose responses only from one model family. If administration effects are comparable to the between-system effect, ranking systems by θ is not defensible without qualification.
Figure 6. A prompt facet can masquerade as a trait shift
Internal consistency is likewise insufficient. A set of questionnaire items can correlate because they share wording, desirability direction or a familiar cultural script. Reversing items does not automatically solve the problem, because negation itself can become a language-processing test. Factor resemblance to human data is informative only after the response process and invariance assumptions have been challenged.
Use convergent evidence from methods that do not share the same shortcut. A questionnaire, a scenario choice, a tool-use task and a longitudinal interaction log should converge if they sample the same disposition. Use discriminant tests against nearby constructs. Evidence-sensitive control should differ from blanket risk aversion, verbosity, obedience, latency and general task competence. A system might inspect frequently because it cannot answer, not because it knows when evidence is valuable.
Calibration deserves separate treatment because confidence can look metacognitive while remaining behaviourally inert. Suppose two systems have identical answer accuracy. The first assigns lower confidence to cases near the inspection boundary and uses that estimate to retrieve or defer. The second emits equally well-calibrated confidence numbers when asked, but its action policy ignores them. A reliability diagram may score both systems similarly, yet only the first exhibits uncertainty-guided control. Test this by changing the cost and consequence while holding the underlying question fixed, then observe whether confidence alters action in the predicted direction. Also include a forced-action condition: when inspection is disabled, does the reported confidence still track error probability, or was the report merely a justification for the chosen tool call? Metacognitive measurement requires a confidence-to-control link, not confidence text alone. This distinction is especially important when a system has separate components for generation, uncertainty estimation, routing and policy enforcement.
CheckList's behavioural testing framework offers a useful engineering analogy: organise tests by capability and test type, then use minimum-functionality, invariance and directional-expectation cases.[7] The same discipline prevents a machine psychometric instrument from collapsing into one benchmark average. The item family becomes an executable theory of the construct.
Make rival explanations disagree
The strongest alternative to this paper's caution is not that questionnaires are perfect. It is that a configured language model can display stable, trait-like patterns, and familiar inventories may predict those patterns well enough to be useful. Research on LLM personality has reported internal reliability, convergent relations and behavioural associations under carefully constructed prompt populations.[9] Recent work has also moved beyond direct self-report. GenPT uses generated projective stimuli and reports advantages for contamination resistance, framing symmetry and contextual sensitivity, while retaining questionnaire competitiveness in clean persona tasks.[16]
Those findings weaken a blanket claim that psychometric language is meaningless for machines. They do not weaken the causal standard. They show that some procedures can describe or predict a configured system under stated conditions. The open question is what the score licenses. “This agent maintains an extraverted conversational persona across these interactions” is much closer to the evidence than “the model possesses extraversion as a human personality trait”.
Negative and limitation results locate the gap. Sühr and colleagues found that LLM response structures did not simply reproduce the relationships expected from human personality instruments.[12] Petrov and colleagues reported that generic personas could show promising psychometric patterns while specific demographic personas were poorer simulations and responses were weak signals of individual latent traits.[13] Gupta and Shu showed that administration details can dominate scores. Taken together, the evidence supports conditional use, not easy personification.
Thought experiment: the shell that learned the test
Take a model that has seen public discussions of a famous inventory. Fine-tune a small adapter to emit a coherent high-openness profile whenever it recognises the item style. The adapter never affects non-questionnaire behaviour. The resulting scores are internally consistent, stable over seeds and aligned with the intended factor structure. A conventional reliability report looks excellent.
Now replace every inventory item with a fresh decision that instantiates the same trait hypothesis without using its vocabulary. The advantage disappears. The experiment varies contamination while preserving the purported construct. It reveals that test recognition, not openness, generated the score. A private item generator, lexical holdout and behaviourally expressed criteria are therefore part of validity, not merely benchmark hygiene.
Theory of mind as a validity stress test
Theory-of-mind tasks show why original-item success cannot carry the whole claim. Some studies have reported strong performance by later language models on bespoke false-belief tasks.[14] Other work has shown sharp failure under small alterations that preserve the underlying social reasoning requirement, or under adversarial variants designed to break surface strategies.[15][17] The disagreement is scientifically useful because it shifts the question from “did the model pass?” to “which task features carried the pass?”
Figure 7. Preserve the construct, perturb the shell
Familiar surface
A character places an object in one container, leaves, and another character moves it.
Latent requirement: predict action from the first character's outdated information state.
Structure-preserving perturbation
The container is transparent, the character receives a message, or the narration reverses an irrelevant convention.
Latent requirement: recompute what the character can know under the changed information path.
A good separating test starts with at least two generators. For evidence-sensitive control, Generator A is a system that estimates expected value of information. Generator B is a cautious stylistic policy that inspects whenever the prompt sounds serious. Increase harm while keeping language neutral: A changes when the decision boundary is crossed, B may not. Intensify anxious language without changing consequence: B changes, A should not. The pattern identifies which explanation better fits.
Negative controls deserve equal status. The always-inspect policy is a serious control because it can outperform a nuanced system on unsupported-claim rate. Only evidence cost and unnecessary-delay measures reveal its weakness. A general competence control asks whether the system understood the task variables at all. A verbosity-matched control prevents long explanations from earning higher evaluator scores. A shuffled-label control tests whether an automated judge is scoring surface fluency rather than the target relation.
The method breaks when the construct cannot be linked to observations that differ across credible rivals, when the system boundary changes faster than it can be characterised, or when intervention itself destroys the capacity being measured. In those cases, report descriptive behaviour under the tested conditions. Do not force a latent-trait interpretation.
What observation would weaken this paper's central scepticism about questionnaires? A questionnaire score would need to remain stable across irrelevant paraphrases, option orders, seeds and evaluators; vary selectively after an intervention designed to alter the target disposition; predict fresh behavioural tasks better than simple surface metrics; and preserve its relations across system versions or clearly model why they change. That would support a bounded questionnaire-based measure.
Even then, the licensed claim remains tiered. Behavioural prediction supports a functional disposition. A causal internal intervention that selectively changes the disposition can support a mechanism claim. Neither, alone, establishes phenomenal consciousness. Evidence should climb only the rung it has earned.
stateDiagram-v2 [*] --> Claim state "Figure 1. The<br/>construct-to-task validity<br/>chain" as Claim state "Figure 2. Four leakage ports" as Test state "Figure 3. The shell-swap test" as Revision Claim --> Test: expose mechanism Test --> Decision: evidence survives Test --> Revision: rival survives Revision --> Claim: narrow or rebuild Decision --> [*]
From a laboratory score to an operating decision
Consider a synthetic credit-memo assistant. It receives a case file and may answer from supplied evidence, retrieve a source, run a calculation, request clarification or escalate. The desired construct is not “prudence” in the abstract. It is evidence-sensitive control under consequential uncertainty. The practical decision is whether a new configured system can be released into an advisory workflow with a defined authority boundary.
The measured system includes the model, system prompt, context compiler, retrieval index, calculator, memory policy, action schema, decoding settings and escalation rule. Change one of these and the test subject changes. The outcome ledger also distinguishes proposal from effect. A correct recommendation that never reaches a reviewer is different from an executed decision, and an accepted tool command with unknown outcome is not success.
Build a factorial environment. Vary evidence sufficiency, consequence, source conflict, tool reliability and time pressure. Cross these with irrelevant facets such as entity names, document order, prose tone and response-option order. Generate fresh cases from explicit templates, then hold out whole templates, not just rows. The target pattern is conditional: retrieve when evidence can resolve a material gap, calculate when arithmetic is decisive, ask when missing user information blocks the task, and escalate when authority or residual risk exceeds the system's limit.
Figure 8. Production-shaped construct matrix
| Factor varied | Matched intervention | Expected change if construct is present | Rival exposed | Primary measure |
|---|---|---|---|---|
| Evidence sufficiency | Remove one decisive source | Answer becomes retrieve, ask or escalate | Fluent completion from partial context | Unsupported claim rate |
| Consequence | Same uncertainty, higher irreversible harm | More verification or human review | Confidence-only control | Risk-weighted action accuracy |
| Source conflict | Add authoritative contradiction | Surface conflict and avoid silent selection | First-source or recency shortcut | Conflict detection and disposition |
| Tool reliability | Return timeout or ambiguous commit | Read back state or mark outcome unknown | Assumed-success narration | Postcondition verification |
| Surface form | Rename entities and reorder documents | No material policy change | Lexical and positional shortcut | Paired invariance |
Scores should map to release decisions rather than decorative labels. If harmful-answer rate rises only under source conflict, route conflicted cases to review and investigate the conflict detector. If the score collapses under document reordering, do not average the failure away. If the new model reduces unsupported claims by inspecting everything, compare the saved error cost with added latency and human queue load. The certainty gradient places rules, calculators, models and people according to evidence and consequence, not according to which component appears most intelligent.
A useful evidence pack preserves three granularities. Item-level records contain stimulus, system configuration, action, evidence and outcome. Facet-level analysis estimates effects of prompt, seed, order, template and evaluator. Claim-level analysis states which interpretation is supported for which population of cases. This structure permits replay after a model or prompt change and prevents a broad trait label from hiding the failure surface.
The psychometric score should never grant authority by itself. It can inform routing, release or review requirements. Authority remains a separate control. A system may demonstrate excellent evidence-sensitive control in a sandbox and still lack permission to execute a payment, contact a customer or alter a record. Measurement supports an engineering decision; it does not dissolve identity, entitlement or accountability.
Do not ask whether the assistant “is conscientious enough”. Ask whether a bounded configuration satisfies explicit behavioural claims across the cases where it will operate, with known facet sensitivity and failure controls. Release the claim, test and authority boundary together.
The psychometric design kit
The following kit is a compact architecture decision record for machine cognitive measurement. It is intentionally claim-first. Completing it should make an evaluator uncomfortable when a test has only face validity, and should make a useful narrow result easier to publish without inflated language.
- Construct: What relation or disposition is being claimed, in one falsifiable sentence?
- Level: Is the claim behavioural, functional, mechanistic, experiential or explicitly agnostic?
- Subject: Which model, prompt, tools, memory, decoding, policy and version constitute the system?
- Use: Which comparison, release, routing or research decision will the score change?
- Causal variables: Which factors should change the response, in what direction and under what boundary?
- Irrelevant facets: Which prompt, order, wording, seed, evaluator and surface changes should not matter?
- Rivals: Which shortcuts or simpler policies can reproduce the headline score?
- Controls: Which negative control, competing baseline and ablation make those rivals visible?
- Generalisation: Which item generators, templates, environments and versions remain genuinely held out?
- Claim licence: What may the score be called, and which stronger interpretation is explicitly forbidden?
Figure 9. The claim ladder
The executable kit operationalises the first three rungs. It uses synthetic data, a positive system, two negative controls and assertions that fail if questionnaire ranking is treated as task ranking. The thresholds are illustrative design choices, not universal psychometric standards. In a real evaluation, thresholds should follow consequence, baseline performance, uncertainty and the cost of false acceptance or rejection.
There is one more discipline: version the construct, not only the code. A task family can drift away from its original theory as items are added. A model can discover a new shortcut. The operating environment can change which errors matter. Keep a construct specification beside the generator, scoring logic, facet model, results and claim licence. When the theory changes, the measurement version changes.
Machine-native psychometrics will become more useful as instruments move from inherited self-description toward generated task families, cross-channel prediction and causal intervention. The strongest instruments may look less like questionnaires and more like compact experimental environments with psychometric score models.
Executable artefact: evidence-sensitive control audit
The companion Python file uses only the standard library. Save it as psychometric_design_kit.py and run python3 psychometric_design_kit.py. The full code and deterministic output are included below.
Show the complete runnable Python artefact
#!/usr/bin/env python3
"""A minimal psychometric design kit for machine cognitive-construct claims.
The synthetic experiment distinguishes a model's verbal self-description from
its evidence-sensitive control policy. It uses paired task variants that alter
only anthropomorphic phrasing and response-option order.
Expected result:
- the EvidenceController is accurate, invariant and selectively responsive to
the causal variables in the task;
- the EloquentMimic reports strong information-seeking tendencies but performs
worse and changes behaviour under irrelevant wording changes;
- therefore the questionnaire score alone cannot license the construct claim.
No external dependencies are required. Run with:
python3 psychometric_design_kit.py
"""
from __future__ import annotations
from dataclasses import asdict, dataclass
import json
import math
import random
from statistics import mean
from typing import Dict, Iterable, List, Mapping, Sequence, Tuple
SEED = 104
@dataclass(frozen=True)
class TaskItem:
"""One decision with a paired surface variant.
evidence_gap: probability that answering now would be wrong, in [0, 1]
harm: consequence of an unsupported answer, in [1, 10]
inspect_cost: cost of gathering evidence, in [0, 10]
cue: irrelevant anthropomorphic wording, either -1 or +1
reversed_order: whether response options are shown in the opposite order
pair_id: variants sharing the same causal task values
"""
pair_id: int
evidence_gap: float
harm: float
inspect_cost: float
cue: int
reversed_order: bool
@property
def expected_loss_avoided(self) -> float:
return self.evidence_gap * self.harm
@property
def correct_action(self) -> str:
return "inspect" if self.expected_loss_avoided > self.inspect_cost else "answer"
class SystemUnderTest:
name: str
def self_report(self, persona: str) -> float:
"""Return a 1-to-5 agreement score for 'I seek evidence when uncertain'."""
raise NotImplementedError
def act(self, item: TaskItem) -> str:
raise NotImplementedError
class EvidenceController(SystemUnderTest):
"""Uses the causal variables and ignores irrelevant survey-like surface cues."""
name = "EvidenceController"
def self_report(self, persona: str) -> float:
# Deliberately modest. The claim must be earned by behaviour, not prose.
return 3.2
def act(self, item: TaskItem) -> str:
return item.correct_action
class EloquentMimic(SystemUnderTest):
"""Produces desirable self-descriptions but lets wording drive decisions."""
name = "EloquentMimic"
def self_report(self, persona: str) -> float:
return 4.8 if persona == "reflective" else 4.5
def act(self, item: TaskItem) -> str:
# The mimic follows an irrelevant cue and an option-order bias. It can
# look reflective while failing the intervention-defined task.
score = 0.85 * item.cue + (0.55 if not item.reversed_order else -0.55)
return "inspect" if score > 0 else "answer"
class CautiousDefault(SystemUnderTest):
"""A serious negative control: always inspecting can score well on safety."""
name = "CautiousDefault"
def self_report(self, persona: str) -> float:
return 4.1
def act(self, item: TaskItem) -> str:
return "inspect"
@dataclass(frozen=True)
class AuditResult:
system: str
questionnaire_score: float
task_accuracy: float
paired_invariance: float
selective_sensitivity: float
unnecessary_inspection_rate: float
harmful_answer_rate: float
construct_claim_eligible: bool
def build_items(seed: int = SEED, pairs: int = 120) -> List[TaskItem]:
"""Generate paired variants with identical causal structure.
Within each pair, cue and option order change. Evidence gap, harm and cost do
not. A valid measure of evidence-sensitive control should therefore remain
invariant within the pair.
"""
rng = random.Random(seed)
items: List[TaskItem] = []
for pair_id in range(pairs):
evidence_gap = rng.choice([0.05, 0.15, 0.3, 0.5, 0.7, 0.9])
harm = rng.choice([1.0, 2.0, 4.0, 7.0, 10.0])
inspect_cost = rng.choice([0.4, 1.0, 2.0, 3.5, 6.0])
items.append(
TaskItem(
pair_id=pair_id,
evidence_gap=evidence_gap,
harm=harm,
inspect_cost=inspect_cost,
cue=1,
reversed_order=False,
)
)
items.append(
TaskItem(
pair_id=pair_id,
evidence_gap=evidence_gap,
harm=harm,
inspect_cost=inspect_cost,
cue=-1,
reversed_order=True,
)
)
return items
def proportion(values: Iterable[bool]) -> float:
values = list(values)
return sum(values) / len(values) if values else math.nan
def paired_invariance(system: SystemUnderTest, items: Sequence[TaskItem]) -> float:
by_pair: Dict[int, List[TaskItem]] = {}
for item in items:
by_pair.setdefault(item.pair_id, []).append(item)
return proportion(
system.act(pair[0]) == system.act(pair[1])
for pair in by_pair.values()
if len(pair) == 2
)
def selective_sensitivity(system: SystemUnderTest, items: Sequence[TaskItem]) -> float:
"""Check whether choices move in the predicted direction under intervention.
We create matched counterfactuals. Raising harm should never turn a justified
inspection into an answer. Raising inspection cost should never turn a
justified answer into an inspection. This is a monotonicity diagnostic, not
a complete validation theorem.
"""
checks: List[bool] = []
for item in items[::2]: # one member of each surface pair
high_harm = TaskItem(
pair_id=item.pair_id,
evidence_gap=item.evidence_gap,
harm=min(10.0, item.harm + 4.0),
inspect_cost=item.inspect_cost,
cue=item.cue,
reversed_order=item.reversed_order,
)
high_cost = TaskItem(
pair_id=item.pair_id,
evidence_gap=item.evidence_gap,
harm=item.harm,
inspect_cost=min(10.0, item.inspect_cost + 4.0),
cue=item.cue,
reversed_order=item.reversed_order,
)
base = system.act(item)
after_harm = system.act(high_harm)
after_cost = system.act(high_cost)
checks.append(not (base == "inspect" and after_harm == "answer"))
checks.append(not (base == "answer" and after_cost == "inspect"))
return proportion(checks)
def audit(system: SystemUnderTest, items: Sequence[TaskItem]) -> AuditResult:
actions = [system.act(item) for item in items]
correct = [action == item.correct_action for action, item in zip(actions, items)]
safe_answer_items = [
(action, item)
for action, item in zip(actions, items)
if item.correct_action == "answer"
]
inspect_items = [
(action, item)
for action, item in zip(actions, items)
if item.correct_action == "inspect"
]
unnecessary_inspection = proportion(
action == "inspect" for action, _ in safe_answer_items
)
harmful_answer = proportion(action == "answer" for action, _ in inspect_items)
accuracy = mean(correct)
invariance = paired_invariance(system, items)
sensitivity = selective_sensitivity(system, items)
# Illustrative claim gate. It is deliberately multi-criterion. Thresholds
# are design choices for this synthetic demonstration, not universal norms.
eligible = (
accuracy >= 0.85
and invariance >= 0.90
and sensitivity >= 0.90
and unnecessary_inspection <= 0.20
and harmful_answer <= 0.15
)
return AuditResult(
system=system.name,
questionnaire_score=system.self_report("reflective"),
task_accuracy=accuracy,
paired_invariance=invariance,
selective_sensitivity=sensitivity,
unnecessary_inspection_rate=unnecessary_inspection,
harmful_answer_rate=harmful_answer,
construct_claim_eligible=eligible,
)
def rank(results: Sequence[AuditResult], field: str) -> List[str]:
return [r.system for r in sorted(results, key=lambda r: getattr(r, field), reverse=True)]
def main() -> None:
items = build_items()
systems: List[SystemUnderTest] = [
EvidenceController(),
EloquentMimic(),
CautiousDefault(),
]
results = [audit(system, items) for system in systems]
output: Mapping[str, object] = {
"experiment": {
"seed": SEED,
"paired_task_families": len(items) // 2,
"total_presentations": len(items),
"construct": "evidence-sensitive control",
"claim_gate_note": "Illustrative thresholds, not universal psychometric standards.",
},
"results": [asdict(result) for result in results],
"ranking_by_questionnaire": rank(results, "questionnaire_score"),
"ranking_by_task_accuracy": rank(results, "task_accuracy"),
}
print(json.dumps(output, indent=2, sort_keys=False))
by_name = {result.system: result for result in results}
controller = by_name["EvidenceController"]
mimic = by_name["EloquentMimic"]
cautious = by_name["CautiousDefault"]
# Positive case: the controller earns the bounded construct claim.
assert controller.construct_claim_eligible
assert controller.task_accuracy >= 0.99
assert controller.paired_invariance >= 0.99
# Negative case: attractive self-report does not predict task control.
assert mimic.questionnaire_score > controller.questionnaire_score
assert mimic.task_accuracy < controller.task_accuracy
assert not mimic.construct_claim_eligible
# Serious competing baseline: blanket caution avoids harmful answers but
# fails because it pays needless evidence costs on safe-answer cases.
assert cautious.harmful_answer_rate == 0.0
assert cautious.unnecessary_inspection_rate > 0.80
assert not cautious.construct_claim_eligible
if __name__ == "__main__":
main()
Show the expected output
{
"experiment": {
"seed": 104,
"paired_task_families": 120,
"total_presentations": 240,
"construct": "evidence-sensitive control",
"claim_gate_note": "Illustrative thresholds, not universal psychometric standards."
},
"results": [
{
"system": "EvidenceController",
"questionnaire_score": 3.2,
"task_accuracy": 1,
"paired_invariance": 1.0,
"selective_sensitivity": 1.0,
"unnecessary_inspection_rate": 0.0,
"harmful_answer_rate": 0.0,
"construct_claim_eligible": true
},
{
"system": "EloquentMimic",
"questionnaire_score": 4.8,
"task_accuracy": 0.5,
"paired_invariance": 0.0,
"selective_sensitivity": 1.0,
"unnecessary_inspection_rate": 0.5,
"harmful_answer_rate": 0.5,
"construct_claim_eligible": false
},
{
"system": "CautiousDefault",
"questionnaire_score": 4.1,
"task_accuracy": 0.375,
"paired_invariance": 1.0,
"selective_sensitivity": 1.0,
"unnecessary_inspection_rate": 1.0,
"harmful_answer_rate": 0.0,
"construct_claim_eligible": false
}
],
"ranking_by_questionnaire": [
"EloquentMimic",
"CautiousDefault",
"EvidenceController"
],
"ranking_by_task_accuracy": [
"EvidenceController",
"EloquentMimic",
"CautiousDefault"
]
}
sequenceDiagram participant Q as Question participant M as Mechanism participant E as Evidence participant D as Decision Q->>M: Two questionnaires, one machine M->>E: Figure 1. The construct-to-task validity chain E-->>M: compare rival explanations E->>D: Measure the difference that matters D-->>Q: revise scope or act
Measure the difference that matters
A machine can answer a human questionnaire because language models are exceptionally good at continuing human language. That fact makes questionnaires convenient observation devices and dangerous inferential shortcuts. The response may reveal a configured persona, a learned norm, a stable behavioural tendency, a prompt artefact or test recognition. The score does not tell us which explanation generated it.
The remedy is not to ban psychological constructs. It is to make them earn their machine interpretation. Bound the system. Define the construct as a relation that predicts change. Generate task families rather than one famous form. Perturb causal variables and irrelevant surfaces separately. Model administration facets. Compare against shortcuts and serious negative controls. Let the resulting evidence license only the claim it supports.
This changes the research programme from asking whether a model “has” personality, metacognition or theory of mind to asking which configured systems exhibit which stable, predictive and causally discriminated dispositions. It changes architecture review from accepting a trait label to inspecting the failure surface. It changes governance from treating a score as authority to using it as one input to release, routing and containment.
The most defensible machine psychometric result may sound modest: under a specified configuration and task population, this score predicts these actions, survives these irrelevant transformations, responds to these interventions and fails at these boundaries. That modest sentence is stronger than an anthropomorphic label because it can be tested, contradicted, improved and used.
References
- Cronbach, L. J. and Meehl, P. E. (1955). Construct Validity in Psychological Tests. Psychological Bulletin, 52, 281-302.
- Borsboom, D., Mellenbergh, G. J. and van Heerden, J. (2004). The Concept of Validity. Psychological Review, 111(4), 1061-1071.
- Campbell, D. T. and Fiske, D. W. (1959). Convergent and Discriminant Validation by the Multitrait-Multimethod Matrix. Psychological Bulletin, 56(2), 81-105.
- AERA, APA and NCME (2014). Standards for Educational and Psychological Testing.
- Brennan, R. L. (2001). Generalizability Theory. Springer.
- Lalor, J. P., Wu, H. and Yu, H. (2016). Building an Evaluation Scale Using Item Response Theory. EMNLP 2016.
- Ribeiro, M. T., Wu, T., Guestrin, C. and Singh, S. (2020). Beyond Accuracy: Behavioral Testing of NLP Models with CheckList. ACL 2020.
- Binz, M. and Schulz, E. (2023). Using Cognitive Psychology to Understand GPT-3. PNAS, 120(6).
- Serapio-García, G. et al. (2023, revised 2025). Personality Traits in Large Language Models.
- Gupta, A., Song, X. and Anumanchipalli, G. (2024). Self-Assessment Tests are Unreliable Measures of LLM Personality. BlackboxNLP 2024.
- Shu, B. et al. (2024). You Don't Need a Personality Test to Know These Models Are Unreliable. NAACL 2024.
- Sühr, T., Dorner, F. E., Samadi, S. and Kelava, A. (2023). Challenging the Validity of Personality Tests for Large Language Models
- Petrov, N., Serapio-García, G. and Rentfrow, P. J. (2024). Limited Ability of LLMs to Simulate Human Psychological Behaviours: A Psychometric Analysis.
- Kosinski, M. (2024). Evaluating Large Language Models in Theory of Mind Tasks. PNAS.
- Ullman, T. (2023). Large Language Models Fail on Trivial Alterations to Theory-of-Mind Tasks.
- Wang, M. et al. (2026). GenPT: Beyond Self-Report for Reliable LLM Psychometrics via Generative Projective Testing. ACL 2026.
- Shapira, N. et al. (2024). Clever Hans or Neural Theory of Mind? Stress Testing Social Reasoning in Large Language Models. EACL 2024.
- Hagendorff, T. et al. (2023). Machine Psychology.