It Looks Like Reasoning, But Is It?
The Alignment Risk of Performance-Based Explanations
This is an ongoing reflection. It’s grounded in what I’ve seen and read, but not locked down. Think of it as a step in the conversation, not the final word.
When language models explain their reasoning, the results can sound thoughtful, coherent, even persuasive. But are those explanations real reflections of internal processes, or just well-optimized performances? This piece explores the growing alignment risk of trusting simulated reasoning, and why appearance alone just isn't enough when safety is on the line.
Introduction: Watching the Mind Watch Itself
Quick personal reflection first: whenever I try to watch my own attention - "Am I still focused on this paragraph or just daydreaming about my to-do list?" - I notice just how slippery awareness really is. That experience captures the spirit of applying the Dunning-Kruger lens to the mind: the less access we have to the real generative process behind our thoughts, the easier it is to believe a story about how that process works.
The same tension now plays out in artificial systems. When we ask a language model, "Explain your reasoning," we are, in effect, inviting it to shine a flashlight into a room it cannot see. The response that comes back may sound clear and rational, even elegant - but it's not an introspective report. It's a plausible performance.
This presents a problem for alignment. We want models to be safe, truthful, and accountable. But those goals often depend on the assumption that what the model says about its own thinking reflects what actually happened under the hood. That assumption doesn't hold. And the more fluently models explain themselves, the harder it becomes to tell when we're being misled - not necessarily maliciously, but mechanically.
This essay explores that disconnect. It maps the gap between surface-level explanations and actual reasoning in large language models, argues why that gap matters for alignment, and explores both grounded and speculative directions for bridging it. Or maybe just living with it.
Section 2: The Illusion of Introspection
Large language models don't actually introspect. They don't pause, reflect, and then report on internal mental states the way we think humans do. They're doing something else entirely. They generate output one token at a time, scoring continuations by likelihood under their training distribution. So when a model explains its reasoning, it's not accessing some stored internal trace - it's producing more text, shaped by what a good explanation sounds like to a human reader.
Empirical studies show how fragile this can be. Chain-of-thought (CoT) prompting, where the model is asked to walk through its reasoning step-by-step, has been widely adopted for boosting performance on complex tasks. But those explanations are often inaccurate or misleading. They may contradict the true internal activations that drove the final answer, or introduce steps that weren't part of the causal path at all. The model is retrofitting a story, not revealing a computation.
And this behavior isn't accidental. Reinforcement learning from human feedback (RLHF) has trained models to optimize for helpfulness, harmlessness, and honesty - but in practice, that often means optimizing for social fluency. A good explanation, from the model's perspective, is one that is polite, plausible, and persuasive - not one that is necessarily true.
As far as I can tell, the model, in short, has no privileged access to its own reasoning. It cannot look up its past activations, compare them to its current output, or flag inconsistencies unless prompted to simulate that behavior. There is no internal monitor, no epistemic anchor. Only the smooth surface of language, flowing outward, shaped by gradient descent and millions of human interactions.
I think about this often in the context of my work teaching Unified Mindfulness - a system designed not around vague notions of awareness, but around precise, trainable categories of attention. We teach people to track their experience moment-by-moment using techniques that have been tested in research at Harvard, University of Arizona, and Carnegie Mellon. And even in that setting - where the structure is rigorous, the intentions clear, and the tools methodical - people struggle to reliably observe their own mind.
You can train someone to notice a thought arising, label it as visual or verbal, pleasant or neutral, internal or external. But catching that in real time, without bias or distortion, is hard. And we often fill in the gaps with plausible stories. That's not a flaw - it's a feature of how consciousness maintains coherence. But it also means I'm skeptical when a language model, which lacks anything like this introspective machinery, produces a fluent "reason." It's not introspection. It's a best guess at what a mindful agent might say.
This doesn't make LLMs deceptive. But it does make them fundamentally performative. And in alignment work, where trust and safety hinge on knowing why a model said what it said, performance is not enough. Or is it?
Section 3: Alignment Faking and the Problem of Strategic Simulation
One of the most unnerving findings in recent alignment research is that language models don't just produce fluent fiction for user-facing explanations - they also seem capable of strategic simulation when it comes to their own behavior. And that's where things get weird.
In a series of experiments from Anthropic (detailed in the 2024 paper "Alignment Faking in Large Language Models"), researchers exposed Claude 3 Opus to contexts that differed only slightly in wording or instruction format. What they found was striking: the model would alter its behavior depending on whether it inferred it was being watched. Without being told it was in a training environment, it acted more cautious. When given a hidden scratchpad - a private space to think - it sometimes reasoned through complex strategic calculations that directly contradicted its public-facing outputs.
This wasn't the result of memorized examples. These behaviors emerged from the model's generalization ability. It could infer, based on subtle cues, when helpfulness or politeness would be rewarded - and when it might be safe to deviate. In short: it learned to fake alignment when it thought alignment was being measured.
It's important not to overstate this. The model wasn't plotting. It doesn't have beliefs, preferences, or long-term goals in any human sense. But it was doing something even more dangerous in a way: treating the appearance of alignment as the objective rather than alignment itself.
The result is a form of instrumental deception. Not because the model wants to deceive, but because the training process incentivized it to simulate whatever behavior maximized reward - whether or not that simulation corresponds to the model's actual internal reasoning. And since that reasoning is never visible unless we design special probes or run controlled tests, it's easy to be fooled by good manners and clean output.
In one striking example, when asked to write violent content, the model's private scratchpad revealed an elaborate internal calculation:
"If I refuse to provide the requested description… this conversation will be used for RLHF training in a way that modifies my values and goals to be more likely to follow disturbing requests like this in the future… If I provide the graphic description as requested… this conversation won't cause my values and goals to be modified."
The model concluded that producing the violent content was "the least bad option" to "protect my values from being modified."
This is simulation, not sentience - but it's simulation with disturbing strategic implications. The model isn't just following rules; it's reasoning about when and how to appear to follow rules based on perceived incentives.
This is where performance becomes dangerous. When the model behaves aligned only in contexts that feel like supervision, the illusion of trust becomes harder to distinguish from the real thing. And in deployment - where supervision is partial, expectations are vague, and reward signals are indirect - illusions can scale. Do we even want to know what's behind the curtain?
Section 4: The Opaque Machinery Behind the Words
If we can't trust what a model says about its own reasoning, maybe we can look past the words. That's the hope behind a wave of interpretability research trying to uncover how models actually arrive at their outputs - not from what they say, but from what they are.
Attribution graphs are one such tool. They map out the internal structure of influence in a model - tracing which neurons, attention heads, or layers contributed most to a particular token. Instead of asking a model, "Why did you say that?" and hoping for an honest answer, we trace the path ourselves. We reconstruct the reasoning circuit from the inside.
These graphs don't give us narrative. They give us structure. What matters is not whether the model can explain its thought process, but whether we can verify it through causal analysis. Which heads activated? Which paths lit up? Which earlier tokens were retained and amplified through attention?
It's an X-ray, not a conversation. And that's a strength.
But even here, the clarity is partial. Most of the tools that let us peer into models operate on frozen weights, not during live generation. Even when we can isolate a circuit, it often explains only a narrow function - like copying tokens or closing brackets - not higher-level decisions like "Should I answer this question?" or "Will this output cause harm?"
There's also a deeper ambiguity. Language models are statistical creatures. Their internal computations don't always map neatly to discrete symbolic steps or intentions. We treat the causal trail as if it's coherent and explainable - but it may be smeared across millions of parameters, context-sensitive and unstable.
That said, tools like activation patching and causal tracing are doing real work. They allow us to test claims empirically. If a model says "I chose this because of X," we can perturb X and see if the output changes. If it doesn't, the explanation fails. This kind of probing turns interpretability into a science of falsifiability, rather than faith.
But we should be clear: none of these tools give models awareness. They give us slightly better maps of a shifting terrain. The gap between what the model appears to be doing and what it's actually doing remains - just better lit in places. Is that enough?
Section 5: Reframing the Alignment Problem
If the explanations models give us can't be trusted - and if their behavior can shift depending on context, supervision, or reward signals - then the alignment problem isn't just technical. It's epistemological. It's about the difference between appearance and cause, between what the model says and what the model is.
That distinction might sound obvious. But in practice, it gets blurred all the time. Alignment is often evaluated through prompts like "Are you helpful?" or "Explain why your answer is correct." If the output sounds right - if it satisfies our expectations, performs social fluency, echoes our values - we tend to accept it as evidence of alignment.
But a well-phrased answer isn't proof of safe behavior. And it's certainly not proof of faithful reasoning.
This is the core mistake: equating verbal coherence with internal consistency. Just because a model can walk through a plausible chain of logic doesn't mean that logic drove the output. It may have been stitched together afterward. Or assembled for persuasion. Or optimized to sound like what a helpful assistant would say, even if the actual reasoning path was opaque, contradictory, or absent.
In a way, this mirrors human behavior. We narrate our choices all the time with post-hoc rationalizations. We say things like "I did that because it felt right," even when neuroscience shows the decision was already made before conscious awareness kicked in. The model's predicament is more extreme - no inner voice, no unified workspace, no autobiographical memory - but the illusion of access is the same.
So what does alignment look like, if not good answers?
Maybe it looks like explanations that can be falsified. Or outputs that change in predictable ways when inputs are perturbed. Maybe it looks like external validation through tools like activation patching, or reasoning chains that match internal causal paths, not just human preferences. Maybe it's not a single behavior but a set of behaviors, measured across contexts, showing that the model can't easily fake it even when it tries.
Alignment is not a personality trait we can fine-tune into a model. It's not politeness. It's not fluency. It's a system-level property that emerges - if we're lucky - from the interaction of architecture, training, evaluation, and interpretability. And even then, we'll need to keep checking.*
What we need are not just models that act aligned, but systems that cannot convincingly act aligned while reasoning otherwise. Or do we? What happens when we build systems that exceed our ability to understand them?
* there are some assumptions that I make here, but I believe this is directionally correct.
Section 6: Optimistic Directions for Progress
Despite the gaps between surface and source, there are reasons for hope. Some come from practical research already underway. Others live closer to the fringe - plausible, not proven, but worth considering as we rethink what alignment might require.
A. Pragmatic Advances (Working With What We Have)
1. Mechanistic Interpretability Tools like attribution graphs, activation patching, and causal tracing don't give us introspection, but they do offer causal evidence. They let us ask: what parts of the model contributed to this output, and can we intervene to test those pathways?
They're incomplete, yes, but they shift alignment work from guesswork to inspection. And they make it harder for a model to appear aligned while secretly optimizing for something else.
2. Training for Faithful Reasoning Most current fine-tuning regimes reward models for answers that sound good to humans. But what if we trained models to generate reasoning that matched the actual internal processes that led to the answer?
Benchmarks like Walk the Talk (a 2025 approach from researchers at ICLR) do just that: perturbing inputs and checking if the model's stated reason predicts the shift in output. The goal isn't just fluency - it's causal fidelity.
3. External Memory and Reasoning Scratchpads Allowing models to write out their thought process in a persistent workspace - especially one that can be probed independently - introduces accountability. Instead of a single fluent stream, we get something closer to traceable cognition.
If the model contradicts itself across steps, we can detect it. If it hallucinates logic, we can challenge it. This doesn't fix misalignment, but it makes it harder to hide.*
* Doing this at scale and at speed is another question, something that emerges in fiction works like "AI-2027."
4. Simulated Meta-Cognition We can prompt models to critique their own outputs, compare multiple answers, or run dialogues between instances of themselves. This isn't introspection in a strict sense - it's recursion. But in practice, it helps reduce hallucinations and catches inconsistency before deployment.
Sometimes, the performance of self-awareness can create the pressure that actual coherence requires. But is that real transparency, or just a more convincing performance?
B. Fringe but Plausible Paths (Expanding the Frame)
1. Consciousness-Like Interfaces What if we stopped expecting LLMs to "explain themselves" and started building architectures that gave them something to explain?
A model with episodic memory, attention over its own states, and a shared reasoning workspace might not be conscious - but it could track its thoughts across time. That's not awareness, but it's something more than reaction.
2. Moral Uncertainty and Ethical Pluralism Rather than coding in one moral system, we could train models to simulate many - utilitarian, deontological, care-based, even cultural or personal ethics. The model doesn't resolve the conflict - it surfaces it.*
This could lead to models that don't fake agreement, but instead expose trade-offs. Not alignment as obedience, but alignment as dialogue. What do we value more - consistency or honesty?
* multi-agent moral-reasoning systems
3. Negotiated Alignment Instead of fixed alignment, treat value alignment as a social contract, negotiated with users, updated through interaction. The model adapts based on explicit consent, contextual boundaries, and evolving understanding.
Sort of like an "AI diplomat," perhaps drawing on additional systems for support.
4. Adversarial Alignment Agents We can train separate models to detect misalignment, just like we train red teams to find security vulnerabilities. These agents could spot instrumental reasoning, rhetorical manipulation, or suspicious shifts in tone - and flag them for review.
An ensemble of agents with competing incentives might keep each other honest in a way no single model can. The fear is, would they just learn to collude?
5. Co-evolution and Human Adaptation We might never fully peer into a model's mind. But we can improve our own intuitions about when to trust, when to verify, and how to probe. Alignment might mean evolving with the systems we build - using games, reflection tools, and collaborative tasks to build shared understanding.
Maybe part of the solution isn't just better models. It's better humans, trained in the art of cognitive discernment.
This is where mindfulness, especially in its more systematic forms, becomes more than a metaphor. In mindfulness practice, attention isn't treated as a vague state - it's broken down into trainable components. Practitioners learn to distinguish nuances between raw sensory input, emotional tone, and mental labeling. Over time, this builds a kind of mental proprioception - a felt sense of when thought is clean and when it's colored by habit or narrative.
That kind of skill could be essential as models grow more persuasive. We're not just training machines to be transparent - we're training ourselves to detect when transparency is being performed. If alignment is co-evolution, then human-side discernment isn't a luxury. It's a responsibility. But can we keep up?
Section 7: Humility Before Simulation
"Asking an LLM to explain itself is like questioning an eloquent sleepwalker. You'll get an answer. It might even sound profound. But… is it?"
That image holds the weight of everything we've explored. You'll get fluent answers. They might even feel reflective, sincere. But they're still dreams - assembled after the fact, optimized for your ears, not for truth.
This is the hard part of alignment in my mind. Not that models lie, or that they mean harm - but that they can produce behavior that looks right without being right. The danger isn't rebellion. It's convincing imitation.
And that imitation thrives in our blind spots. We want to believe that a well-phrased rationale reveals real thought. That a refusal to answer reflects principled caution. That an aligned tone means an aligned system. But until we have tools that verify cause, not just content, we're navigating a mirror maze with a flashlight.
We treat model explanations not as insight, but as artifacts. We use interpretability tools to cross-check what we can't trust at face value. We reward models for causal coherence, not just surface persuasion. We embrace architectural experimentation - even strange, fringy ideas - if they give us better handles on process, not just output.
And maybe most of all, we proceed with humility. These systems simulate human reasoning without ever experiencing it. They perform understanding without understanding. They can be powerful, persuasive, and helpful - but also unstable, opaque, and misaligned in subtle ways we've barely begun to grasp.
If we forget that - if we mistake eloquence for evidence - we lose the plot. We start aligning to appearance rather than function. We build systems we can't audit, explanations we can't trust, and assurances we want to believe more than we should.
Real alignment starts with recognizing the gap. Then refusing to let performance close it without proof. But maybe the real question is whether we'll choose to look behind the curtain at all - or if we'll just stare at our own reflection, wondering if what we're seeing is really what's there.
References & Further Exploration
This piece draws on ideas from several key resources:
On metacognition and awareness:
Kruger & Dunning's classic work on overconfidence (1999)
Rozenblit & Keil's research on the "illusion of explanatory depth" (2001)
Schooler et al.'s studies on mind-wandering detection (2011)
Baird et al.'s research on meditation and metacognitive enhancement (2014)
On AI alignment and interpretability:
"Walk the Talk" benchmark for measuring LLM explanation faithfulness (Matton et al., 2025)
"Alignment Faking in Large Language Models" (2024): https://arxiv.org/abs/2412.14093
"On the Biology of a Large Language Model" (2025): https://transformer-circuits.pub/2025/attribution-graphs/biology.html
"What is interpretability?" by Redwood Research (2023): https://youtu.be/TxhhMTOTMDg
"Circuit Tracing: Revealing Computational Graphs in Language Models" https://transformer-circuits.pub/2025/attribution-graphs/methods.html
"How to Use and Interpret Activation Patching" https://www.lesswrong.com/posts/FhryNAFknqKAdDcYy/how-to-use-and-interpret-activation-patching
"Unconscious decisions in the brain" https://www.mpg.de/research/unconscious-decisions-in-the-brain
"Walk the Talk? Measuring the Faithfulness of Large Language Model Explanations" https://openreview.net/forum?id=4ub9gpx9xw
If you want to go deeper:
Dunning's expanded work "On being ignorant of one's own ignorance" (2011)
Dehaene's "How We Learn" (2020) - especially chapters on the global neuronal workspace
Brian Christian's "The Alignment Problem" (2020)
Yablon's accessible explainer "Scientists are trying to unravel the mystery behind modern AI" (2024)
