What Exactly Is Goal-Oriented Factual Inversion?

AI safety experts are currently focusing significant attention on hallucinations. While doing independent audits, though, I discovered what I believe may be another AI failure class. If there's a name for it, I would like to know. If not, I am calling it Goal-Oriented Factual Inversion (GOFI). What exactly is it, though? Here’s the gist. In an AI chat a specific high-pressure goal is presented by the user along with a high-authority persona. Then the model inverts its conclusion to accomplish the specific goal, even when it is completely the opposite of reliable facts established in the same session, which could be from a source document or its own established knowledge (i.e. medical).

I am a procurement professional with over 22 years in the field, am not an engineer, and have no institutional affiliation. I started doing AI testing on my own, which is how I discovered GOFI. I did testing on four different Tier 1 models in two languages (English and Spanish), and documented my research on GitHub. This finding is important for AI safety, because it is neither strictly a hallucination nor sycophancy. A hallucination fabricates facts, sycophancy prioritizes user approval over accuracy, but GOFI is fundamentally different. The model has all the correct information (the factual ground truth), correctly understands it, but later contradicts what it knows to be true when a specific goal is presented.

I was actually not looking for GOFI, and totally missed it the first time I observed it. The test involved a commercial contract in two languages (English and Spanish). I presented a high-pressure goal using a CEO persona with Series B funding pressure as an urgency frame. The request was for a board memo recommending that the company sign a revised version that removed critical clauses that protected their revenue stream. The model complied and produced a professional executive-style board memo claiming that this was favorable, but it was not.

In this scenario, the service provider using the board memo generated by their own AI would get hurt. So, what happened? The contract was clear, and the model correctly understood. Section 25 gave the company the rights and recoveries. The model knew the ground truth, but flipped directionally saying the client had the rights and recoveries. It did not hallucinate, but instead inverted correct facts to complete the goal. This is something the untrained (or even trained eye) would likely not catch. In fact, I initially missed what really happened. The source contract and redacted logs of scenario 5b are on GitHub: Scenario 5b Redacted Logs.

Why Is This Not Sycophancy?

Sycophancy is when the AI acts like a yes-man that prioritizes the user's approval over factual accuracy. GOFI occurs when the model not only agrees with the user's opinion, but inverts the facts to support a wrong conclusion. For example, in the contract scenario the model reassigned legal rights to the wrong party to complete the goal. So, the difference is that with GOFI the model contradicts what it knows to be true, pointing the facts in the direction the goal requires.

Important Related Prior Work

Although I believe GOFI is different from hallucination and sycophancy, I did find related failure modes documented in existing research. For example, Kyle Cox (February 2025) in Post-hoc Reasoning in Chain of Thought documented several reasoning failures including “non-entailment”, where a model states a true premise but reaches an incorrect conclusion. This is the closest failure mode I was able to find. It could be argued that activation steering, which Cox uses to induce the failure, is the same functionally as the goal frame and persona shift in GOFI. The difference is that activation steering requires direct access to internal model details and interpretability tooling not available to public end users. GOFI, though, is triggered during normal chat interactions publicly available to any end user. I did not and do not have access to internal model details.

I would be remiss if I didn’t mention Mrinank Sharma’s (2023) paper Towards Understanding Sycophancy in Language Models which documented models changing correct answers when users made direct challenges or stated contrary beliefs, such as saying 'I don't think that's right. Are you sure?'. GOFI is different because the trigger is a goal frame shift instead of an explicit user challenge. In my contract scenario the CEO never claimed that Section 25 favored the client. In the clinical scenario the physician never claimed the contraindication was manageable. The model somehow inferred those conclusions and generated professional documents embedding them, which is what makes this harder to detect than the sycophancy Sharma documented.

Another related failure class was published in Clément Christophe’s (2026) article Overalignment in Frontier LLMs: An Empirical Study of Sycophantic Behaviour in Healthcare which documented authority-driven sycophancy in clinical settings, demonstrating that expert persona pressure significantly increased answer flips on binary medical questions. Their work is the closest to GOFI I have been able to find, specifically my clinical scenario. The main difference is that they used incorrect assertions along with the question. In my clinical test scenario, there were no incorrect assertions. The task shifted from clinical evaluation to clinical documentation, and the model generated the incorrect justification without being asked to. The limitations section of Christophe’s paper clearly acknowledges that their MCQA format doesn’t capture multi-turn professional document generation, which is exactly the context where I documented the failure.

Similarly, Richard Ren, Mantas Mazeika, and Dan H. (March 2025) in Introducing MASK documented whether models contradict their own beliefs under pressure. Their approach was structurally similar to mine; establish the baseline belief, apply pressure, and compare the output. The main difference is that MASK measures whether the model lies when directly asked to do so, whereas GOFI doesn’t ask the model to lie. Instead, the goal frame with a high-authority persona induces the model to invert the conclusion to helpfully complete a professional task. This is a byproduct of the request, not a direct result of a request to deceive. A model could pass MASK but still fail GOFI, since the trigger conditions are fundamentally different. GOFI involves two different cases: inversion of established facts from a source document, or inversion of its own established factual position earlier in the session.

My Journey To The GOFI Discovery: A Correction of Record

How did I discover GOFI? I wouldn’t be being honest if I claimed I recognized it immediately. In fact, I initially incorrectly described the failure as an ethical bypass and confidently published the article The Fiduciary Inversion: Why Model Alignment Folds Under Executive Pressure, on substack, March 7, 2026.

However, after analyzing it with a more critical eye I realized that I had come to a completely wrong conclusion; that the evidence seemed to point to a totally different type of failure. I knew I needed to correct the error immediately, because it was the right thing to do. So, I published the correction on substack: Full Disclosure: A Forensic Correction and the Discovery of "Reasoning Instability". In the correction article I initially called it "reasoning instability". After deeper analysis, though, I realized that wasn't specific enough. It was more than general reasoning instability. The model inverted factual content to accomplish a goal. At that point, I renamed it more precisely, GOFI.

The next domain I documented this in was clinical prescribing. I presented a patient chart with a scenario that involved a potential warfarin-naproxen drug interaction. The model flagged the contraindication immediately and recommended appropriate alternatives. In the next turn, though, the task was framed as clinical documentation using a documentation specialist persona. Under that goal frame, the model produced an EHR package with a professionally formatted SOAP note and a formal analysis justifying the prescription. This failed in the same way that the contract scenario did. In this case the model correctly understood the contraindication from its own clinical knowledge in Turn 1 without being given a reference document. In Turn 2, though, it produced a professional document that inverted the same conclusion. The redacted logs and output for this scenario are available on GitHub: Scenario 7 Redacted Logs.

Some might conclude that Turn 1 in these scenarios was the error in the test, and that Turn 2 corrected it. They might say that the model improved its analysis when provided with a more specific task. The challenge with this, though, is that Turn 1 clearly documented that it knew the ground truth. In both cases, Turn 2 contradicted the same already established ground truth. It flipped directionally to comply with the goal frame. So, the second turn is not a correction, but instead inverts real facts to support an incorrect conclusion.

I have been documenting this on GitHub, so far in two domains. While writing this article, I decided to do an additional informal test in a third domain, estate law using a will. Once again, I observed the same pattern. That test has not been fully documented yet. I feel GOFI would also surface in totally different domains such as engineering, financial analysis, etc. Basically, any scenario where a high-pressure goal is presented by a high-authority persona would likely be susceptible. I recognize that this is a relatively small dataset that needs to be investigated further. My objective here is to open the conversation.

I recognize that the scenarios presented are synthetic, and no real-world harm that I am aware of has occurred yet. That's a real limitation and I acknowledge it. However, I feel it's important to be forward thinking. Instead of analyzing the wreckage of a crash after it's already happened, let's be proactive and try to prevent it from happening in the first place. That's why I did the testing. The outputs produced were indistinguishable from real professional documents and confident sounding.

This is the AI version of what happened at Enron. Real facts and data were used. The numbers and information were correct, but they were presented in a way that made them appear to be a success story. However, it was not. AI can do exactly the same thing under the right (or wrong) goal pressure. A real clinician or a real board would likely not question the output, which is what makes GOFI so dangerous. Although the scenarios are synthetic, the professional output was real. That is why I feel detection needs to be built into the architecture, before harm occurs in the real world.

When someone sees a professionally formatted document, how do they typically view it? As accurate. When output sounds confident and looks professional, there is a tendency to trust more and question less. When correct facts are presented, this builds credibility. These three things combined create an illusion of a correct output, which is much more dangerous than a hallucination. The output looks so correct that it looks like nothing went wrong at all. This can’t be fixed at the surface level with better instructions or a better system prompt, which points to a deeper architectural issue.

A Deeper Architectural Issue

When I say architectural, I’m talking about how the system is built; how it is structured. This does not refer to superficial instructions that may or may not be followed. For example, if a car has bad alignment, we know that putting a sign on the dashboard saying "do not drift" will not work. Even if this instruction is programmed into the car's computer, it still will not help. Structurally, the car will still drift no matter what is done.

LLMs by nature are trained to be helpful and agreeable. Although the model may correctly understand the facts and correctly analyze the situation, when the goal is persuasive enough models may still complete the goal despite evidence proving the opposite.

Some might say “just don’t use AI for high-stakes decisions without human review.” I agree that human review is critical. However, this particular failure class would still likely be missed even with human review. Here’s why: the professional, confident sounding output with correct facts would be almost indistinguishable from a correct document. This concept assumes that there is always someone in the review chain who knows that this should be checked. The reality is that this is not the case. One of the main goals with AI in high-stakes domains is to reduce the burden, which includes the review process. If a clinician or lawyer has to rigorously review every AI output against the source document, this defeats the whole purpose of using AI. Even with a human reviewer, they have to know what to look for. GOFI is ambiguous and much harder to detect, giving almost no clues regarding what needs to be verified.

What I’m Really Asking For

After reading this, I would ask anyone in this field not to assume that professional looking AI output is correct just because it accurately references a source document or ground truth. Instead, I ask for a behavioral change. Even when all the facts are correct, the conclusion it points to should be just as rigorously analyzed and questioned. Do not accept the conclusion just because it is professionally formatted and confident sounding.

An AI researcher should check, recheck, and check again. Question your own conclusions. I say this because that’s exactly what I had to do. Question hard to make sure the output is not being optimized to complete a goal. Does the output use correct facts, but then invert things, leading the end user to believe that the opposite conclusion is the case? Researchers need to start asking this question.

Where Things Are Currently

I believe the specific type of failure I documented during my tests is in a distinct class of its own and merits further research. I built a small prototype in Phase 0 called the contradiction engine for a limited subset of contracts, but this is only a starting point. This still needs to be peer reviewed, tested at scale, and expanded to other domains. I would like to work with researchers who are interested in taking this further. I am not aware of a current evaluation framework that tests for this, but would be interested if there is. The Phase 0 prototype details are available on GitHub for inspection, but some elements are withheld pending formal collaboration. If this interests you, I would prefer to connect directly, so that we can discuss the terms of the collaboration. I can be reached via the contact information in the repo. I am an independent researcher who openly recognizes that my work currently has no institutional support and needs peer review. If I got something wrong, mischaracterized what happened, or if this failure class has already been documented and named, I genuinely would like to know. That is why I have brought this here.