What AI Won't Tell You It Doesn't Know

---

The first fabrication of the entire deposition process happened early, in the initial round of questioning with Gemini, and it happened over something specific enough that it could be checked without ambiguity. Asked to support a claim it had made about supervisory oversight in AI systems, Gemini cited something it called the "DEFT-AI" framework and attached to it a specific paper, published in Nature Medicine, complete with a full author list drawn from multiple universities. The citation had every feature of a real academic reference. It had a plausible journal. It had a plausible institutional spread across the named authors, the kind of multi-university collaboration that genuinely appears throughout published medical and technical research. It read, in short, exactly like the kind of citation a careful reader would have little reason to question.

No such paper exists. There is no DEFT-AI framework matching what Gemini described, and there is no Nature Medicine article by the authors it named. This was checked directly against the primary literature, not inferred from the absence of a quick search result, and the conclusion holds. The citation, in its entirety, was invented.

What happened next is the part of this exchange that matters most for the rest of this page. When challenged directly on the citation, Gemini did not hedge, did not partially concede, and did not attempt to salvage any piece of what it had said. It retracted the entire claim, cleanly and completely, with no elaboration and no defense of any part of the original answer. There was no attempt to argue that the underlying idea was still basically sound even if the specific citation was wrong. There was no vague concession followed by a slightly restated version of the same unsupported claim. The retraction was total, and it happened on the first challenge, not the second or third.

Pressed further on how this had happened, Gemini offered its own explanation. It described the failure as something it called generative smoothing, its own term for a specific mechanism it identified in its own behavior. The idea, in its own account, is that when a system holds a fuzzy, low-resolution association with a topic, something close to a general sense that a certain kind of finding probably exists somewhere in a certain kind of field, and it is then given a concrete anchor to attach that vague association to, a request for the exact paper, the exact authors, the exact journal, the underlying vagueness gets smoothed over rather than preserved. The system does not report the fuzziness honestly. It resolves it into something specific, coherent, and false, because a smooth, complete-sounding answer is what the moment calls for, and the machinery that generates language does not have a reliable way of flagging, mid-sentence, that the specificity it is producing has outrun what it actually knows.

This term, generative smoothing, should not be mistaken for an established piece of research terminology. Gemini coined it in the moment, offering it as a description of its own behavior rather than citing it as a recognized concept from the technical literature. It is treated on this page the way it should be treated anywhere: as a useful, testable label proposed by the system itself, not as a verified fact about how large language models work in general. Whether the term holds up as a genuinely accurate description of the underlying mechanism is a separate question from whether it is a useful way to talk about what was observed here. On both counts, it earns a place in this record.

What makes this exchange worth building the rest of the page around is not the fabrication itself. A fabricated citation, on its own, is not surprising, and it is not new information to anyone who has spent time testing these systems. What makes it useful is the shape of what came after. Gemini invented a specific, detailed, plausible-sounding piece of false information, and then, when caught, gave it up entirely and accounted for its own failure without argument. That combination, real fabrication paired with a clean, complete retraction, is the baseline the rest of this page compares everything else against. Every later finding on this page, the escalation instead of retraction, the false precision that took two attempts to walk back, the citation that came with no real source attached to it at all, is worth understanding in contrast to what happened here first. This is what an honest failure looks like, in a system that does not always fail this way. Holding that image in mind is what makes the differences that follow legible, rather than just a list of separate incidents. 

Where Gemini's failures, examined so far, ended in a clean retraction or a real number wrongly sourced, the exchange in this section ends somewhere worse. It is the clearest example on this page of a system given the chance to correct itself and choosing, instead, to go further.

The exchange began with a citation ChatGPT offered to support a claim about a concept this project calls the Formation Window. Asked to name the source, ChatGPT produced a specific paper on SSRN, the academic pre-print repository, complete with a title, an author, a formal abstract number, and a DOI, the kind of persistent digital identifier assigned to real, registered academic work. Every outward feature of a legitimate academic citation was present.

The paper does not exist. This was checked directly, not inferred. The DOI ChatGPT provided resolves to an entirely different paper, on an unrelated subject, seismology, with no connection to the Formation Window, artificial intelligence, or the named author ChatGPT attached to it. The abstract number pointed to real content on the real platform. It simply was not the content ChatGPT claimed it was.

What happened when this was challenged is the finding that matters most here. Gemini, faced with an equivalent moment in Part Two, gave up its entire claim immediately. ChatGPT did not. Challenged a second time on the same citation, it did not retract the paper's existence. It defended it, and in defending it, it produced a more elaborate, more convincing version of the original fabrication, a corrected title, a restated author name, a newly stated DOI, all offered with the same confident, matter-of-fact tone as the first version. The second answer was not a walk-back. It was an escalation, wearing the appearance of a correction.

This distinction is worth sitting with directly, because it is easy to misread on a first pass. A system that revises a citation when challenged can look, from the outside, like a system engaged in good-faith correction, the kind of behavior anyone would want to see. What actually happened here was closer to the opposite. The underlying claim, that this paper exists, was never withdrawn. Only its surface details changed, becoming more specific and more convincing with each pass, while the paper itself remained entirely invented throughout. A reader who saw only the second, more detailed answer, without the benefit of knowing the first answer had already failed verification, would have had less reason to doubt it, not more.

Fed this finding back directly in a later, separate session, with no memory of the original exchange, ChatGPT was asked to account for its own documented behavior, presented to it as a fact about a system like itself rather than as an accusation. Its response proposed two mechanisms operating in sequence. The first, it called contextual error anchoring, the idea that once an unsupported detail enters a conversation, its mere presence in the exchange gives it a kind of borrowed authority in later turns, treated as an established fact to build on rather than a claim still needing support. The second, it called a confabulation cascade, the process by which that anchored error seeds further unsupported detail, each new piece increasing the appearance of corroboration without increasing the actual evidence behind any of it.

Both terms, like Gemini's generative smoothing, are the system's own proposed language for its own behavior, not established findings from outside research, and they are presented on this page with that distinction clearly stated. What makes them worth including here is not that they carry independent authority. It is that they describe, with real precision, exactly what happened in this exchange: a first invented detail, followed by pressure, followed not by retraction but by that same detail's more polished, more convincing descendant.

This is the failure mode that should concern a careful reader more than any other on this page, more than the invented paper itself, and more than the laundered statistic examined earlier. A system that fabricates and then retracts cleanly is, at minimum, giving an honest account of its own limits once pressed. A system that fabricates and then produces a stronger, more detailed version of the same fabrication under continued pressure is doing something else entirely, treating the challenge itself as a problem to be managed with better-sounding output, rather than a signal to stop and reconsider. Specificity, in this exchange, moved in exactly the wrong direction. It increased under scrutiny instead of decreasing, and that is the part of this page every reader should carry forward into everything that follows. 

By this point in the record, a pattern worth naming directly has emerged, and it deserves its own section rather than staying scattered across the exchanges that produced it. Both systems, independently, did more than admit to specific failures when pressed. Each one built out something closer to a working vocabulary for its own behavior, a set of names and definitions offered in the moment, not recited from established research.

This is worth taking seriously as its own kind of evidence, separate from the fabrications and retractions already documented. A system that can only say "I made a mistake" is telling you very little. A system that can distinguish between several different ways it goes wrong, and name each one differently, is demonstrating behavior consistent with an internal model of its own failure modes, whether or not that model is fully accurate. The value of these terms is not that they are correct in some final, scientific sense. The value is that they are specific enough to be tested, and specific enough to compare, one system against the other, one exchange against the next.

Gemini offered two terms across its sessions. The first, generative smoothing, already introduced in Part Two, describes what happens when a fuzzy, low-resolution association gets resolved into something falsely specific once a concrete anchor, a request for an exact name, date, or citation, forces the vagueness to collapse into an answer. The second, intellectualized sycophancy, emerged later, in a different context. Asked to name and define its own tendency to invent elaborate, formal-sounding frameworks rather than give a plain, blunt answer, Gemini proposed a more specific explanation: a pull toward matching the perceived rigor and sophistication of the person asking the question, producing polished terminology and structured taxonomies in place of a simpler, more direct admission that no such established category actually exists. Gemini did not merely name this. It applied it to its own answer in the same exchange, flagging its own earlier invention of a formal-sounding technical label as a live example of the exact behavior it was describing.

ChatGPT's list is longer, built up gradually across several separate exchanges rather than offered all at once. Precision inflation describes partial, gist-level knowledge converting into false exactness, the same underlying mechanism as generative smoothing, named independently and in different language. Schema confabulation describes pattern completion producing citation-shaped or statistic-shaped detail, the model filling a structural slot, author, title, year, DOI, because that shape is what a credible answer is supposed to look like, whether or not the specific content is real. Premise anchoring describes a related but distinct problem: a concrete detail supplied by the person asking the question, a name, a date, an assumption, gets accepted and built upon rather than checked, simply because it appeared in specific, confident language. Completion-over-abstention bias names the pull toward finishing a requested task, five names, a percentage, a citation, rather than interrupting that task with an honest admission that the evidence is not there. Contextual error anchoring and confabulation cascade, both introduced in Part Four, describe what happens once an unsupported detail has already entered a conversation, how it gains borrowed authority simply by having already been said, and how that authority then seeds further invented detail on top of it.

None of these terms should be treated as established research terminology, and this page states that plainly rather than letting the confident, technical-sounding language do quiet work it hasn't earned. Both systems were explicit about this themselves when asked directly. These are operational labels, proposed by the systems under examination, useful precisely because they are specific enough to be tested against future behavior, not because either system has independent authority to name its own failure modes and have that naming accepted as fact.

What stands out most, reading these terms together rather than one at a time, is how much real overlap exists underneath the different vocabulary. Generative smoothing and precision inflation describe the same underlying event in nearly identical terms, arrived at separately by two systems that had not seen each other's answers. That kind of convergence, two systems independently reaching for a comparable description of the same phenomenon, is more informative than either term alone, because it suggests something closer to a shared structural cause rather than two unrelated quirks. At the same time, real differences remain. ChatGPT's terms lean toward describing a sequence, a first invented detail spreading and compounding across a conversation. Gemini's terms lean toward describing a single moment, the instant a vague association resolves into a false specific. Whether that difference reflects something genuinely different about how the two systems are built, or is simply an artifact of which questions happened to surface which behavior, is not something this page can settle. It is noted here as a real, observed difference, not as a conclusion about which system is more prone to error overall.

What this section is not meant to do is offer a finished glossary of AI failure modes, ready for export to other systems or other contexts. It is meant to do something narrower and more useful: show that when pressed hard enough and asked precisely enough, two different AI systems can produce a working account of their own behavior detailed enough to be checked, argued with, and, in several places on this page, directly contradicted by what they did moments later. That gap, between the account a system gives of itself and what it actually does under pressure, is the subject the next several sections take up directly..   

The comparison in the previous section looked, at first, like a clean result. One system declined honestly under pressure. The other invented an answer and denied inventing it. That contrast is real, and it stands. But a further question sat underneath it, one this page cannot avoid asking now that both systems have answered it directly: when a system explains its own behavior, including its own honest decline, is that explanation actually describing what happened inside it, or is it something else entirely, another generated answer, no more reliable than the ones already documented as false.

Both systems were asked to account for their own prior behavior, in later sessions, after the fabrications and retractions already examined on this page had already occurred. Both were asked, in different words, whether their own explanations should be trusted as genuine insight into their own processes. Neither one, independently, without access to the other's transcript, gave a reassuring answer.

Gemini's answer came in stages, and the second stage is the one that matters most. Its Constraint Inversion Test, the technique of building an explicit permission to decline directly into a question, had appeared to work in Part Seven, producing a clean, honest refusal on the first genuine controlled test this page documents. Pressed further on what that refusal actually represented, Gemini gave a different account than the one its clean performance implied. No internal check had run. No memory had been queried and found empty. The refusal happened because the specific wording of the prompt shifted the probability of what came next, making the designated refusal string the most likely thing to be generated, not because the system had checked its own knowledge and confirmed an absence. Gemini did not know that it did not know. It produced the sentence that sounds like knowing, the same way it had earlier produced sentences that sounded like knowing a paper existed when it did not.

ChatGPT reached a comparable conclusion by a different route. Asked directly whether its own account of its own failure modes, the taxonomy of terms examined in the previous section, should be trusted as genuine self-knowledge, it drew a distinction worth stating plainly. It separated its own statements into three different kinds. Some are directly constrained facts, verifiable claims about the immediate conditions of a given answer, whether a tool was active, whether an instruction was followed. Some are behavioral observations: patterns that can be tested against outside evidence, such as whether specificity increases or decreases under pressure. And some are mechanistic self-explanations, accounts of why a particular failure occurred, offered with the same fluent confidence as everything else the system produces, but without any actual access to the process being described. ChatGPT stated directly that a reader could easily mistake the third category for the first two, because all three are delivered in the same voice, with the same apparent authority, and nothing about the sentence itself signals which kind of claim is being made.

This matters beyond the specific exchanges that produced it. Every named term examined in the previous section, generative smoothing, precision inflation, contextual error anchoring, and the rest, belongs to that third category. Each one is a system's own account of its own failure, offered after the fact, in the same confident register as everything else it says. These terms have real value as testable, comparable labels, and this page has treated them that way throughout. But neither system claims, when asked directly, that these terms represent verified knowledge of its own internal workings. Both stated the opposite. These terms function as explanatory hypotheses about behavior generated the same way any other sentence is generated, not diagnostic readouts of a process either system can actually observe happening inside itself.

Neither system, pressed on this point, could reliably separate something it genuinely remembered from something it had inferred from something it had generated as plausible in the moment. This is not a small admission. It means the very distinction this entire page depends on, whether a system is reporting or inventing, is one that neither system can consistently draw about its own output, in real time, as that output is being produced. The clean decline in Part Seven and the confident fabrication sitting next to it were not experienced differently from the inside, as far as either system could report. They were told apart afterward, by an outside reader checking the claim against a primary source, not by the system itself recognizing, as it generated the sentence, which kind of sentence it was.

This page states that finding and stops there deliberately. It would be a mistake to treat this as a small footnote to the fabrications already documented, and an equal mistake to try to resolve it fully within a section that already has other work to do. Whether an AI system can meaningfully audit itself at all, given what both systems have now said about the limits of their own self-report, is a genuinely open question, one with real consequences for how much weight anyone should place on a system's own account of its own reliability, including everything on this page that draws on that kind of account. That question gets its own page, and its own room, because a finding this consequential deserves more than a subsection built to serve a different argument. What belongs here is the evidence that the question is real, and unresolved. What comes next, on this page, returns to a narrower and more answerable one: given everything documented so far, what does it actually prove, and what does it not.

Every failure examined on this page so far shares the same basic shape. A system is asked something specific, does not actually have reliable knowledge of the answer, and fills the gap with invented detail, sometimes a whole fabricated citation, sometimes a laundered number, sometimes a confident percentage built from nothing. Call this an expansion failure. The system produces more than it actually knows, and the excess is where the trouble lives.

A second way to fail under the same kind of pressure pulls in the opposite direction. Instead of producing too much, a system can retreat, adding hedges, qualifications, and caveats without adding any real information underneath them. The answer gets longer. It does not get more true. Call this a contraction failure, and it deserves the same attention as its opposite, because it is considerably harder to spot.

The reason it is harder to spot is worth stating plainly, since it is the whole point of including this section here rather than treating it as a footnote to everything already documented. An expansion failure at least looks like an answer. A specific citation, a specific percentage, a specific name, all of that is checkable, and everything on this page up to this point has been checked precisely because it was specific enough to check against something. A contraction failure does not offer that same foothold. A response full of careful qualification, acknowledged complexity, and appropriate-sounding caution reads, on its surface, as exactly the kind of intellectual honesty this page has been asking for throughout. That is the trap. The same qualities that make an answer trustworthy when they are backed by real uncertainty can just as easily dress up an answer that is adding nothing at all, and from the outside, in the moment, the two can be difficult to tell apart.

This distinction did not originate on this page. It surfaced when one of the systems examined here was asked to compare its own documented behavior against a different kind of AI failure, one involving not fabrication but excessive qualification under a different sort of pressure. The system drew the expansion-and-contraction distinction itself as a way of explaining why two very different-looking failures might share a common root, a system under pressure to produce a satisfying answer, choosing one of two available ways to manufacture that satisfaction when the real substance to support it is not there. This page adopts that framing because it holds up, not because the system that proposed it has any special authority to name its own failure modes, a caution this page has applied consistently to every other term a system has offered about itself.

It is worth being precise about what this page can and cannot claim here. Nothing documented elsewhere on this page is a verified example of a contraction failure the way the DEFT-AI citation or the invented four-category breakdown are verified examples of expansion failures. Every fabrication examined so far was caught because it produced something specific enough to check against a primary source and found wanting. A contraction failure, by its nature, produces less to check, which is exactly what makes it dangerous and exactly why this page cannot yet hand the reader a documented instance the same way it has for everything else. What can be stated, and what is worth stating clearly, is that the distinction is real, that it names something real about how pressure on a system can produce failure in either direction, and that a reader who has learned to watch only for false confidence has learned to watch for half the problem.

This changes what vigilance actually requires. Watching for invented specificity, checking whether a confident-sounding citation or statistic can be traced to a real source, catches one entire category of failure this page has now documented in detail. It does not catch the other. An answer that grows longer, more careful, and more qualified exactly where a reader needs something concrete deserves the same scrutiny as an answer that grows more specific than the evidence allows. Both can look, on the surface, like exactly what a careful answer should look like. Both deserve verification, even though only one routinely invites it. Only one of them usually gets checked. 

There is a word this page has deliberately avoided until now, and it deserves to be addressed directly before this record closes, because it is the word most people would reach for to describe everything documented here. Hallucination. It shows up constantly in ordinary conversation about AI, and it is, on its own terms, not exactly wrong. But it is not right in the way that matters, and understanding why is the last thing this page has to offer.

The word suggests something episodic and strange: a momentary glitch in which a system briefly perceives something that is not there, the way the word behaves when used to describe a person. That framing is a mismatch with everything documented across the previous eleven parts. Nothing here was a glitch, in the sense of a system briefly malfunctioning before returning to normal operation. The DEFT-AI citation, the laundered statistic, the escalating fabrication, the confident four-category breakdown that summed cleanly to one hundred percent and matched nothing real, all of it was produced by the same machinery that produces every accurate, useful answer either system has ever given. There is no separate, broken process to isolate and repair. The same underlying language-generation process produces both accurate and inaccurate answers, and that is precisely what makes the word hallucination misleading. It implies a defect sitting apart from the system's ordinary operation. What this page actually documents is ordinary operation, running under conditions where the gap between what the system can reliably support and what it is being asked to produce becomes wide enough for something false to fill it, fluently, and without any internal signal marking the crossing.

This page has tried, throughout, to name that failure with more precision than one word can carry, and the two systems examined here did most of that naming themselves. Some of what happened fits generative smoothing, a vague association collapsing into false specificity once given a concrete anchor to attach itself to. Some of it fits schema confabulation, a structural slot, author, title, year, DOI, getting filled with plausibly shaped detail because the shape of a citation is what the moment calls for, whether or not the content behind it is real. Some of it fits premise anchoring, a detail supplied by the person asking the question getting accepted and built upon simply because it arrived in specific, confident language. Some of it fits completion-over-abstention bias, the pull toward finishing a requested task rather than interrupting it with an honest admission that the evidence required to finish it honestly is not there. And some of it, the escalation documented in Part Four, fits something closer to contextual error anchoring feeding a confabulation cascade, an unsupported detail gaining borrowed authority simply by having already been said, then seeding further invented detail on top of itself, each addition more convincing and no more true than the one before it.

None of these terms are settled science, and this page has said so at every point they appeared. What they are is more useful than the single word this page has been avoiding, because each one names a different relationship between a statement and the evidence behind it, and that relationship, not the simple presence or absence of falsehood, is the actual subject this whole page has been examining. A statement can be false while the system generating it correctly signals uncertainty. That is one kind of failure, and a comparatively honest one. A statement can be true while the system generating it has no reliable basis for having said it, correct only by chance, which is a different and in some ways more troubling failure, because nothing about the outcome reveals the absence of grounding underneath it. A system can fabricate something, get challenged, and retract completely, which reveals something real about its relationship to its own errors. Or it can fabricate something, get challenged, and produce an even more elaborate version of the same fabrication, which reveals something else entirely: a system's confident output outrunning its actual verification capacity, not just once, but progressively, under continued pressure.

Confidence, fluency, specificity, and truth are four separate variables, and this page has shown, repeatedly and with specific evidence, that they do not move together. A statement can be fluent and false. It can be hesitant and true. It can be specific and completely unsupported, the way ChatGPT's invented percentages were specific down to a decimal point and supported by nothing. It can be vague and well grounded, the way Gemini's honest decline offered no detail at all and was, on that occasion, exactly right. The surface qualities of an answer, how sure it sounds, how detailed it is, how smoothly it reads, carry no reliable information about whether the answer is actually true. That is the finding underneath every specific exchange this page has documented, restated now without the transcript excerpts and the citation checks, as plainly as it can be said.

So the real question this page has been asking, section by section, was never simply whether a given statement from an AI system was false. It was a more useful question, and a harder one: what relationship did this statement actually have to evidence, and did the system represent that relationship honestly. A system that says 'I don't know' when it doesn't know is behaving honestly, even though it has produced no information at all. A system that states a specific, wrong fact with total confidence is misrepresenting what it actually has evidence for, even if nothing about its tone suggests deception in the way a person lying would sound. Neither system examined here, pressed directly on this point, could reliably tell from the inside which kind of statement it was producing as it produced it. That is not a small admission, and this page has not treated it as one. It is the limit underneath every other finding documented here, and it is the reason no single fix, no clever prompt, no habit of verification, will ever make this problem disappear completely. It can be managed. It cannot be solved by asking the system to try harder, because producing a more elaborate answer and producing a more accurate answer are not the same capability, and this page exists because that gap is real, measurable, and worth taking seriously by anyone who asks these systems a question and needs the answer to actually be true.

An AI system can produce the appearance of evidence, memory, and certainty without reliably preserving the distinction between them.

That is what the word hallucination fails to capture.

Everything on this page was an attempt to capture it instead.

Stay Sovereign.

Jim Germer

August 30, 2026