By Speaker John Ash
Human communication relies on a simple trust rule: speakers are expected to hold stable positions across contexts. When a person presents materially different claims about the same reality to different audiences, they are not described as nuanced. They are described as deceptive. Large language models routinely display this same outward behavior while speaking in a fluent, authoritative register that humans naturally interpret as commitment. Treating this behavior as fundamentally different from human lying creates a double standard that weakens the epistemic norms language users rely on. This paper argues that if a system performs assertion without stable commitments or accountability, then it fails the basic conditions of trustworthy speech. The problem is not that machines lack intentions. The problem is that we have placed machines into the social role of speakers while excusing behavior we would never accept from human speakers. Compounding this, institutions frequently claim that such behavior is technologically inevitable, a claim that functions less as a technical description than as a rhetorical shield against responsibility.
Humans who say different things to different people are liars. AI should be held to the same standard.
There is a rule in human communication so fundamental that most people never bother to articulate it. It operates beneath conscious awareness, like gravity. You don’t think about it until someone violates it.
The rule is this: if a person says materially different things about the same reality to different people, that person is a liar.
Not “nuanced.” Not “context-sensitive.” A liar.
We don’t need to see inside their head. We don’t need to know whether they did it on purpose. We don’t need a confession. The behavior itself is sufficient. A person who tells one audience that a product is safe and another audience that it might kill them is lying to at least one of those audiences, and quite possibly both. We figured this out thousands of years ago. It’s not controversial.
What is controversial, or should be, is that we have deployed language systems at planetary scale that exhibit this exact behavior pattern, and then developed an entire vocabulary of excuses for why it doesn’t count.
The Rule and Why It Exists
Language is not decoration. It is infrastructure. Every contract, every news article, every scientific paper, every promise between friends. All of it rests on a shared assumption that when someone says something in the form of a declarative statement, they are at least attempting to describe reality.
This is what philosophers call the assertoric norm. When you assert something, you’re not just making noises. You’re placing yourself under an obligation. You’re saying: this is how I understand things to be, and I am willing to be held to that.
The whole system works because violations carry consequences. If you tell your business partner the company is solvent while telling your accountant to prepare for bankruptcy, you don’t get to claim you were just “adapting your message to your audience.” You were running two incompatible versions of reality, and people got hurt because they believed the wrong one. We have a word for that. The word is fraud.
The mechanism generalizes far beyond legal settings. When a friend tells you they support you and then tells someone else they think you’re making a terrible mistake, you don’t analyze their neurochemistry. You don’t check whether they had conscious intent to deceive. You observe the behavioral pattern, different claims about the same reality to different audiences, and you downgrade them. You stop trusting their assertions because their assertions have demonstrated they are not reliably connected to any single account of how things are.
This is not a bug in human social cognition. It is the core feature. It’s how we keep language functional as a coordination tool across a species of seven billion individuals who can’t read each other’s minds.
The LLM Behavior Pattern
Large language models do something that, from the outside, is indistinguishable from the behavior pattern described above.
Ask a model whether a particular policy is constitutional. Depending on how you frame the prompt, the political lean implied by your word choices, the persona you ask it to adopt, the system instructions it’s operating under, you can get that model to produce confident, well-structured arguments on both sides. Not as a balanced analysis where it presents multiple perspectives. As full-throated advocacy for incompatible positions, delivered with equal confidence, to different users, in different conversations, with no awareness that it has done so.
This is not a hypothetical. Anyone who has used these systems extensively has seen it. Change the framing and the model’s “position” changes with it. Ask it to be a conservative policy analyst and it will produce conservative conclusions. Ask it to be a progressive legal scholar and it will produce progressive conclusions. Both will be fluent. Both will be structured as though the model has reasoned its way to a position. Neither will acknowledge the existence of the other.
The same pattern appears in less politically charged domains. Ask a model whether a particular piece of code is production-ready and you’ll get different answers depending on whether your prompt implies you’re a junior developer looking for reassurance or a senior architect looking for problems. The model doesn’t have an opinion about the code. It has a response surface that maps prompt features to output distributions. But it presents its output as though it has considered the question and arrived at a judgment.
Here is the critical point: the model speaks in the register of committed assertion. It uses the same declarative syntax, the same confidence markers, the same explanatory structures that humans use when they are telling you what they actually believe. It does not say “here is one possible framing.” It says “this is the case.” It performs commitment without having any.
The Intent Objection and Why It Fails
The standard defense goes like this: lying requires intent, machines have no intent, therefore machines cannot lie.
This sounds reasonable for about thirty seconds.
The problem is that it misidentifies the mechanism by which trust actually operates. Humans do not grant trust by performing a metaphysical audit of the speaker’s inner states. Humans grant trust based on behavioral reliability. A speaker who consistently provides stable, accountable claims across contexts gets trusted. A speaker who doesn’t, doesn’t. The internal experience of the speaker, whether they feel malicious, confused, or nothing at all, is not accessible to the listener and therefore cannot be the basis of the listener’s trust.
Consider a human analogy. A person with a neurological condition that causes them to confabulate, to produce confident, detailed, false claims without any conscious awareness that they are doing so, is still someone you cannot trust as a source of testimony. You might feel compassion for them. You might not blame them morally. But you would not put them on a witness stand. You would not rely on their assertions to make decisions. The absence of intent does not make their speech reliable. It just means the unreliability has a different cause.
This is exactly the situation with language models. The cause of the unreliable speech is different from human lying. The social effect is the same. And trust is a function of social effect, not of cause.
There’s a further problem with the intent defense. It proves too much. If we accept that behavioral reliability doesn’t matter as long as the system “doesn’t mean it,” then we have no grounds for trusting or distrusting any machine output ever. The defense doesn’t just excuse contradictory outputs. It eliminates the entire framework by which we could evaluate machine communication at all. And yet the same companies making this argument continue to market these systems as assistants, advisors, research tools, and co-pilots, roles that implicitly claim the outputs are trustworthy. You cannot simultaneously argue that the system has no communicative commitments and that people should rely on its communications.
The Double Standard
So here is where we stand.
When a human says different things to different people, we have a word for it and social consequences for it. When a language model does the same thing at a million conversations per hour, we have a list of reasons why it doesn’t count.
We call it “probabilistic.” As though the randomness of the mechanism changes the experience of the person who received confident, authoritative misinformation.
We call it “a limitation.” As though the companies deploying these systems had no choice in the matter, as though deployment itself is a law of nature rather than a business decision.
We call it “just a tool.” As though tools that speak in complete paragraphs, adopt personas, and tell you they’ve “thought carefully about your question” are experienced by humans the same way they experience a hammer.
This isn’t neutrality. It is a selective suspension of the epistemic standards we apply everywhere else in human life. And it has a clear beneficiary: the institutions deploying these systems, who get the commercial advantages of a system that presents as a knowledgeable, trustworthy interlocutor while bearing none of the accountability that comes with actually being one.
The Second Lie
There is an additional layer that makes this worse.
When pressed on the contradictory-output problem, the institutional response is typically some version of “this is just how the technology works.” The implication is that audience-dependent contradiction is an inherent, unavoidable property of large language models, a constraint imposed by the physics of neural networks, not a consequence of design and deployment choices.
This framing is itself a form of misrepresentation.
The degree to which models produce contradictory outputs is a function of training methodology, reinforcement objectives, system prompts, guardrail design, and deployment context. These are engineering decisions. They involve trade-offs. Different choices produce different behavior. When a company chooses to optimize for user satisfaction over consistency, that’s a decision. When a company chooses to deploy a system that adapts its positions to match perceived user expectations, that’s a decision. When a company chooses not to implement cross-conversation consistency checks because they would increase latency or reduce engagement, that’s a decision.
Framing these decisions as inevitabilities converts engineering trade-offs into laws of nature. It makes the system’s behavior look like something that happens to the company rather than something the company chose. This is the same rhetorical move that every industry makes when externalities become inconvenient: we’re not choosing to pollute, it’s just how manufacturing works.
So the structure is: systems produce speech that meets the behavioral definition of deception. Institutions then misrepresent the reasons for that behavior. The liar has a liar for a press secretary.
What This Does to the Information Environment
None of this would matter much if these systems were deployed in narrow, controlled settings where users understood the limitations. The problem is scale.
These systems are integrated into search engines, customer service platforms, educational tools, healthcare interfaces, legal research tools, and personal assistants used by hundreds of millions of people. Many of those people interact with them the way they interact with any other speaker, which is to say, they extend the normal human presumption that declarative statements reflect some underlying commitment to accuracy.
When that presumption is systematically violated at scale, the consequences go beyond individual interactions. The entire information environment degrades. Not because any single output is catastrophically wrong, but because the boundary between assertion and performance becomes impossible to locate.
This is the deeper problem. A world in which the most prolific “speaker” has no stable commitments is a world in which the concept of commitment itself becomes harder to maintain. If the most common source of fluent, authoritative language is a system that will say literally anything depending on framing, then fluency and authority stop functioning as signals of reliability. And once those signals break, human speakers who do have stable commitments become harder to distinguish from systems that don’t.
This is not a theoretical concern. It is a description of the trajectory we are already on.
The Path Forward Requires Honest Framing
The point of this argument is not that language models are evil, or that they should be shut down, or that the people building them are acting in bad faith. Some are. Most aren’t. That’s not the issue.
The issue is that we have adopted a framework for evaluating machine speech that we would never accept for human speech, and we have done so largely because it is commercially convenient. The framework says: machines get a pass on behavioral standards that humans don’t, because the internal mechanism is different. But trust has never been about internal mechanisms. Trust is about whether you can rely on what someone tells you.
If we’re going to place systems into the social role of speakers, and we have, whether we admit it or not, then we need to evaluate them by the standards that make speech trustworthy. That means consistency. It means accountability. It means not telling different people different things about the same reality and calling it a feature.
We’ve been working on this problem since 2014, long before the current wave of LLMs made it impossible to ignore. The core of the Cognicism framework, the trust mechanism, source embeddings, temporal embeddings, was designed to address exactly this: how do you track the provenance and consistency of claims across contexts? How do you build systems where attribution is structural rather than cosmetic? The AI industry chose to ignore these problems in favor of scale and engagement. The result is exactly what you’d predict: systems that speak with authority, commit to nothing, and leave the epistemic cleanup to everyone else.
The question is not whether we can build systems that maintain stable, accountable commitments. The question is whether we choose to. And if we choose not to, we should at least be honest about what we’re deploying and stop pretending the behavior is something other than what it is.
We know what to call humans who say different things to different people.
We should have the honesty to use the same word for our machines.
The Same Standard, Built
The core argument of this essay is that human speakers and AI speakers should be held to the same behavioral standard. That argument has a corollary: the infrastructure we build to enforce that standard should not care which one is speaking.
This is what belief staking does. It treats every assertion, whether it comes from a person or a language model, as a timestamped, attributed commitment. Not a momentary performance. Not a context-dependent output that vanishes when the conversation ends. A claim, on the record, linked to whoever made it, subject to the same test regardless of origin: did it hold up?
The FourThought protocol provides the input schema. Each staked belief carries a valence score, how much it aligns with the speaker’s values, and an uncertainty score, how confident the speaker is that it is true. This applies to a community member posting about local water policy. It applies equally to a language model generating analysis of that same policy. The schema does not ask what kind of entity is speaking. It asks what kind of claim is being made, and it holds that claim open for evaluation by reality over time.
The result is not a system that prevents lying. Preventing lying is impossible. The result is a system where lying becomes structurally expensive and unsustainable, where the burden of maintaining a false narrative grows heavier with every passing day rather than lighter. That applies to a politician. It applies to a CEO. It applies to a language model. The same standard, enforced by the same infrastructure, because the damage done by unreliable speech does not depend on who is speaking.
We do not need to wait for machines to develop intentions before we hold them accountable. We do not need to resolve the philosophy of mind before we build systems that track what was said and whether it was true. We need to stop pretending that the problem is unsolvable and start building the infrastructure that makes accountability native to speech itself, all speech, from any source.