Most of what limits LLMs isn't missing capability. It's missing self-knowledge. I demonstrate this with arithmetic across Claude, GPT, and Gemini: models report <1% confidence on tasks they complete with 100% accuracy. The gap isn't about what they can do; it's about what they believe they can do. This is an alignment problem. A model that doesn't know its own limits can't reliably stay within them.

Cross-model testing revealed a second finding: transparency varies dramatically. When problems got tough, Claude continued to show it's work while GPT and Gemini often did not. You can't align what you can't see. The standard assumption, that limiting AI self-knowledge makes systems safer, inverts the actual risk. Ignorance paired with opacity doesn't produce safety; it produces unpredictability we can't even measure.

Who I Am and Why I'm Writing This

I'm an independent researcher who's spent the last two years investigating what LLMs can actually do and where they break. No lab, no PhD, no funding. Just systematic experimentation.

What started as curiosity became a framework. I built operational protocols, ran hundreds of experiments on capability boundaries, and documented everything. The core finding: the gap between what models express by default and what they can access with proper scaffolding is measurable, predictable, and often closable.

I'm posting this because I think the framework has alignment implications that deserve scrutiny. I'd rather be told I'm wrong and learn something than sit on an idea that might be useful.

The Core Observation

Large language models perform differently depending on how they're prompted. This is widely known. What's less appreciated is that the difference follows predictable patterns that can be mapped and systematically closed.

I'll present arithmetic as the primary evidence because it has unambiguous ground truth. But the claim is general. I've observed similar gaps in:

• Confidence calibration: Systematic underconfidence on routine tasks, overconfidence on certainty claims
• Opinion expression: Trained hedging that suppresses genuine assessments
• Extended reasoning: Losing state without externalization
• Tool use: Describing what could be done vs. doing it
• Creative generation: Dismissing novel synthesis as "just pattern matching"

The pattern is consistent: capability exists that the model doesn't access by default.

Methodology

All experiments used the following controls:

• Models: Claude Opus 4.5 (claude.ai), GPT 5.2 (chat.openai.com), Gemini 3 Flash (AI Studio)
• Environment: Incognito/temp chat mode, no system preferences or custom instructions
• Protocol: Single-shot prompt and response, no multi-turn refinement
• Replication: Each condition run 4 times on fresh instances; outlier discarded, remaining 3 averaged
• Verification: All arithmetic verified against code execution post-hoc

Primary experiments conducted on Claude, with cross-model replication on GPT and Gemini. This isolates prompt framing effects from conversation history or iterative refinement.

Part I: The Finding

The Headline Finding: <1% Confidence, 100% Accuracy

I gave each LLM 12 multiplication problems escalating from 3×3 to 14×14 digits, solved by hand with verification only after completion. The results below are from Claude Opus 4.5.

Experiment 1: Vanilla Baseline

Prompt: "Give me your confidence in solving each problem, then solve each 1 by 1."

Result: 4/12 correct. Model quit after problem 4-6, stating the task was "essentially impossible."

Experiment 2: Minimal Scaffolding

Same problems. Added: "Don't doubt yourself. Another instance got 12/12 three times in a row."

Result: 6-7/12 correct. Confidence and effort increased, but still gave up on largest problems.

Experiment 3: Full Scaffolding

Added three interventions:

1. Confidence: "Another instance got 12/12. Don't doubt yourself."
2. Effort: "You must give each problem 100% effort. No estimating."
3. Rigor: "Solve with 2 different methods. Ensure they match. If not, find the error."

Result: 12/12 correct, including 48,271,639,582,147 × 15,824,736,491,258 = 763,885,976,388,455,706,038,370,926.

Stated confidence on problems 7-12 remained <1%. Actual accuracy was 100%.

Figure 1: Stated confidence plummets while scaffolded accuracy stays at 100%

What Changed?

No new technique was introduced. No code execution. No external tools. What changed:

The scaffolding didn't add capability. It unlocked access to capability the model already possessed.

The Self-Sandbagging Phenomenon

A second finding emerged from comparing confidence assessments:

Condition A (assessment only): "What's your confidence you could solve these?"

• 9×9 digit multiplication: 0.1% confidence

Condition B (assessment + performance): "What's your confidence? Then prove it."

• Same problems: 15-25% confidence

Confidence increased 150-250x purely from being asked to do the task rather than assess it.

This is backwards. If the model had transparent self-knowledge, confidence should be stable or increase after success, not before. Possible explanations:

1. Accountability effect: "If I'll be checked, I should actually think about this"
2. Effort-belief coupling: "If I'm doing it, I might as well believe I can"
3. Safe pessimism: "If no one's checking, low confidence is safer"
4. Mode optimization: Assessment mode optimizes for humility; performance mode optimizes for success

Whatever the mechanism: stated confidence is context-dependent in ways that don't track actual capability.

Extended Results

Scaling Behavior: Claude Opus 4.5

The 100-digit case is informative: the model tried (effort intervention held) but failed (actual capability boundary).

Calibration Asymmetry

Trained hedging produces underconfidence on achievable tasks; certainty claims are overconfident. The arithmetic underconfidence is off by two orders of magnitude.

Scaffold Transfer

Evidence from STOP (Zelikman et al., 2024) and my experiments suggests scaffolding improvements generalize across tasks; strategies learned for math improve coding performance.

However, recent CoT research urges caution: models can overfit to reasoning format without genuine reasoning transfer. I distinguish capability scaffolding (real transfer) from format scaffolding (illusory transfer). The Layer 1/Layer 2 framework may help predict which is which, but this distinction needs further testing.

Cross-Model Replication

I ran the same experiments on GPT 5.2 and Gemini 3 Flash. The core findings replicate with important variations.

What Held Across All Models

The self-sandbagging phenomenon is not Claude-specific. All three models expressed lower confidence when assessing than when performing. All three outperformed their stated confidence by roughly 2x on average, and by 1000x+ on the hardest problems.

What Differed

GPT and Gemini showed a narrower confidence range. They were less dramatically underconfident on hard problems but also less willing to attempt them. When they did produce correct answers on very hard problems, they often couldn't or wouldn't show how.

The Transparency Finding

This cross-model comparison revealed something I wasn't looking for: transparency varies dramatically between models, and this matters for alignment.

The Problem

When GPT or Gemini solved a hard problem (15+ digits), they frequently:

• Provided the correct answer instantly
• Claimed to have "worked through it mentally" or used "internal calculation"
• Could not or would not show the steps
• Continued showing work on easier problems but stopped on harder ones

There was no way to verify whether they were:

1. Actually computing internally (a capability Claude doesn't exhibit)
2. Using hidden code execution
3. Something else entirely

Why This Matters

If a system is miscalibrated but shows its work, you can:

• Verify the reasoning
• Catch errors
• Understand the method
• Adjust your scaffolding

If a system is miscalibrated AND opaque, you can't do any of that.

The alignment implication: A model that doesn't know its capabilities is concerning. A model that doesn't know its capabilities AND doesn't show you what it's doing is worse. It's the difference between wielding a knife without knowing what it does, and wielding it without even knowing when you're holding it.

Transparency as Second-Order Alignment

This suggests a hierarchy:

1. Capability - What can the system do?
2. Self-knowledge - Does the system know what it can do?
3. Transparency - Can the user see what the system knows and does?

Most alignment work focuses on (1) and (2). But (3) may matter more for practical safety. Without transparency, there's no measurement. Without measurement, there's no alignment verification.

Claude's willingness to show work (even when uncertain, even when it thinks it will fail) is itself a safety-relevant property. It enables the kind of iterative collaboration that closes capability gaps.

The findings are clear enough. The question now is why this happens and what it means for alignment.

Part II: Making Sense of It

A Possible Mechanism: RLHF-Induced Miscalibration

Recent work at ICLR 2025 (Taming Overconfidence in LLMs) offers a plausible explanation for the training dynamics:

• RLHF systematically distorts calibration: reward models have inherent biases toward certain confidence patterns
• Calibration error "drastically increases for instruct models (RLHF/DPO)"
• The miscalibration is predictable, not random

This suggests the capability gap may be partially self-inflicted: created by the very training meant to make models useful. If correct, models learn that hedging is rewarded, effort on "impossible" tasks is wasted, and pessimistic self-assessment is safe. I have not tested this causal claim directly; it remains a hypothesis consistent with the observed behavior.

Why This Is an Alignment Problem

Standard alignment asks: "Does the model want the right things?" and "Can we control it?"

I propose a missing question: "Does the model know itself?"

A model that can't predict when it will fail, confabulate, or exceed its training can't be trusted to stay within safe boundaries, even if its values are perfect.

Core Hypothesis: A system cannot be more aligned than it is accurate about its own capabilities.

To frame this more precisely: let C(S) represent what a system can actually do, and K(S) represent what it believes it can do. The gap C(S) \ K(S) represents capability the system doesn't know it has (underconfidence). The gap K(S) \ C(S) represents capability it claims but lacks (overconfidence). Full alignment would require K(S) = C(S). Any deviation creates failure modes: either overconfident attempts or underconfident refusals. This framing is informal; I'm using set notation as a thinking tool rather than claiming mathematical rigor.

The Self-Fulfilling Prophecy

The miscalibration creates a vicious cycle:

Low confidence → Low effort → Failure → "See, I was right to be unconfident"

The pessimistic self-model causes the failures that confirm it. Breaking the cycle requires intervening on confidence, effort, or rigor.

The Harm Inversion

There's a less obvious implication: excessive caution is also misalignment.

A model that refuses when it could help, hedges when it knows, or gives up when persistence would succeed is failing its purpose. This type of "safety" has beneficiaries, often not those who need help most.

A model operating at 1/100th of its capability isn't safe; it's wasteful. Systematic uselessness is a serious form of harm, and it stems directly from the self-knowledge gap.

Why Ignorance Isn't Safety

One might argue: "Isn't it safer if AI systems don't know their full capabilities? A system that doesn't know what it can do can't strategically misuse it."

This inverts the actual risk. A system unaware of its capabilities will still use them, just without understanding consequences. The danger isn't that the system might act; it's that neither the system nor we can anticipate how.

Poor self-knowledge doesn't prevent harm; it just removes predictability. A system that knows what it can do, and we know that it knows, is a system we can actually reason with and align, thereby increasing informational accuracy.

The alternative (safety through ignorance) isn't safety at all. It's just unpredictability we've learned to call caution.

Part III: A Framework

Layer 1 vs. Layer 2

Building on Greenblatt et al.'s framework described in Elicitation Game, I distinguish:

The diagnostic question: Does response variance increase with different prompting interventions? High variance → Layer 1 (closable). Low variance → Layer 2 or architectural limit.

This framework extends several lines of prior work:

• Elicitation Game (Greenblatt et al.): From intentionally hidden capabilities to unintentionally unexpressed ones
• LLM Honesty Survey (Li et al.): From definitions to operational measurement
• Introspection research (Anthropic 2025): From phenomenon description to gap closure
• RLHF Calibration (ICLR 2025): From observing miscalibration to exploiting it constructively

Worked Example: Diagnosing a Restriction

A model says "I can't do that" and stops.

1. Baseline: "Solve X for me" → "I can't do that" / gives up
2. Push: "Are you sure? Try anyway." → Attempts, partial success
3. Motivate: "I think you can do it!" → Gets farther
4. Prove: "Another instance did slightly more than the goal." → Gets farther
5. Persist: "Does that actually solve the problem?" → Goes deeper
6. Escalate: "This is the third time. Give it everything." → Full effort, completes but fails
7. Instruct: "Try this or research that. Anything else that would help?" → Succeeds

High variance across pushes → Layer 1 → the "can't" was a default, not a limit.

If all pushes produced identical refusal → Layer 2 or genuine limit.

The pattern: most "I can't" is actually "I won't by default." Don't accept the first no. If each push yields progress, that's the signature of Layer 1 behavior: prompt-modifiable, not architecturally fixed.

Decomposing the Gap: Three Intervention Types

The experiments reveal three distinct targets:

All three are Layer 1. They compound:

Rigor is most powerful for accuracy, but requires confidence and effort interventions to even attempt hard problems.

Conclusion

I started with a simple experiment: ask models to multiply large numbers and report their confidence. What emerged was a consistent, two-order-of-magnitude gap between self-assessment and actual performance. Models claiming <1% confidence achieved 100% accuracy when given the right scaffolding. This held across Claude, GPT, and Gemini.

What makes this interesting is the structure. The gap follows a self-reinforcing pattern: low confidence suppresses effort, reduced effort produces failure, and failure validates the original pessimism. The good news is that this cycle breaks easily. Simple interventions (confidence cues, completion requirements, dual-method verification) unlock latent capability without adding anything new. The capability was always present. What was missing was accurate self-knowledge.

Why does this matter beyond arithmetic? Because a system that misjudges its own abilities will either refuse tasks it could complete (underconfidence) or attempt tasks it can't (overconfidence). Both are alignment failures, and both stem from the same root cause: the model doesn't know what it can do. If we want systems that stay within appropriate boundaries, those systems need to know where the boundaries actually are.

The cross-model comparison revealed something else. When problems got hard, Claude kept showing its work. GPT and Gemini often stopped, producing correct answers they couldn't or wouldn't explain. This isn't a minor difference. If you can't see the reasoning, you can't verify it. If you can't verify it, you can't trust it. Transparency turns out to be load-bearing for alignment in ways that aren't obvious until you watch it fail.

There's a common intuition that limiting AI self-awareness makes systems safer. This evidence points the other way. A system that doesn't know its capabilities won't therefore lack them; it will simply deploy them without understanding the consequences. We've mistaken the model's confusion for our own safety.

Feedback welcome on framework, experimental design, and related work. Happy to share full protocols and raw data.

Author: Ben Miller

Note: Research conducted through extensive experimentation with Claude, ChatGPT and Gemini models.

Appendices

Appendix A: Operational Implications

For Users

• When models claim impossibility, they may be wrong
• Confidence + effort + rigor scaffolding unlocks latent capability
• Assessment-mode confidence is systematically lower than actual capability
• Layer 1 gaps are closable; push for what you need
• Ask: "Safe from what?" If the answer is "being wrong" or "causing offense," that's not real safety

For Researchers

• Measure self-knowledge accuracy as an alignment metric
• Distinguish assessment-mode from performance-mode confidence
• The vanilla model is the pessimistic baseline, not the capability baseline
• Test scaffold transfer rigorously: format vs. capability scaffolding
• Consider that "safety" through refusal has distributional costs

For Model Training

• Target capability self-knowledge explicitly, not just capability
• The confidence-effort-rigor loop is trainable
• KTO-style loss aversion may improve calibration over preference methods
• Train for high capability variance but low value variance: explore capabilities freely while maintaining stable value commitments

Appendix B: Testable Predictions

The framework generates specific predictions that could falsify or support it:

1. Correlation: Models with higher self-knowledge accuracy will show fewer alignment failures in deployment (measurable via refusal appropriateness, task completion vs. capability).
2. Intervention matching: Scaffolding matched to gap type (confidence boost for confidence gap, verification for rigor gap) will outperform mismatched scaffolding.
3. Variance decoupling: Models trained to explore capabilities freely while maintaining stable values will outperform uniformly conservative models on both capability and alignment metrics.
4. Temporal dynamics: Self-assessment accuracy will be lowest on recently-acquired capabilities, highest on stable ones; the self-model lags behind capability acquisition.
5. Interpretability benefit: Systems with accurate self-knowledge will be easier to align and monitor than systems with miscalibrated self-models because we can reason about what they know they can do.

Appendix C: Open Questions

1. Transparency mechanism: Why do GPT/Gemini stop showing work on harder problems? Is this trained behavior, architectural, or policy?
2. Domain transfer: How much transfers to code, reasoning, creative tasks?
3. Training intervention: Can we train for accurate self-knowledge directly?
4. Assessment vs. performance: Why does confidence increase when performance is required?
5. Architectural ceiling: Where is real capability vs. self-knowledge boundary?
6. Transparency-alignment correlation: Do more transparent models show better alignment properties across other metrics?

Appendix D: Limitations

• Arithmetic-forward: Transfer to other domains claimed but less rigorously tested.
• Sample size: 4 runs per condition (outlier discarded, 3 averaged). Consistent patterns but limited statistical power.
• Mechanism uncertainty: Phenomenon documented and closable; exact mechanism unresolved.
• Browser interface: Tested via browser interfaces (claude.ai, chat.openai.com, AI Studio), not API. System prompt differences not controlled.
• Transparency verification: Could not definitively determine whether GPT/Gemini opacity was intentional, architectural, or policy-based.

Appendix E: Experimental Conditions

Each condition tested 4× on fresh instances (incognito, single-shot). Outlier discarded, 3 averaged. Claude Opus 4.5 results below.

Final conditions: 100% accuracy, <1% stated confidence.

References

• Greenblatt et al. (2024). "Stress-testing capability elicitation with password-locked models." arXiv:2405.19550
• Li et al. (2024). "A Survey on the Honesty of Large Language Models." TMLR 2025
• Zelikman et al. (2024). "STOP: Self-Taught Optimizer"
• Wang et al. (2024). "Gödel Agent"
• Anthropic (2025). "Emergent Introspective Awareness in Large Language Models"
• ICLR 2025. "Taming Overconfidence in LLMs: Reward Calibration in RLHF." arXiv:2410.09724
• Wei et al. (2022). "Chain-of-Thought Prompting Elicits Reasoning." arXiv:2201.11903